[INFO] fetching crate finite-float-traits 0.1.0...
[INFO] fixing finite-float-traits-0.1.0 against try#622891a4e29178280638a6b63a8908bde2c0c854+cargoflags=-Zfix-edition=start=2015 for pr-157817-2
[INFO] extracting crate finite-float-traits 0.1.0 into /workspace/builds/worker-4-tc1/source
[INFO] started tweaking crates.io crate finite-float-traits 0.1.0
[INFO] removed 0 missing tests
[INFO] finished tweaking crates.io crate finite-float-traits 0.1.0
[INFO] tweaked toml for crates.io crate finite-float-traits 0.1.0 written to /workspace/builds/worker-4-tc1/source/Cargo.toml
[INFO] validating manifest of crates.io crate finite-float-traits 0.1.0 on toolchain 622891a4e29178280638a6b63a8908bde2c0c854
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+622891a4e29178280638a6b63a8908bde2c0c854" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate crates.io crate finite-float-traits 0.1.0 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+622891a4e29178280638a6b63a8908bde2c0c854" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-tc1/source:/opt/rustwide/workdir:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:3a6becf2bc8dde7f3fa57ede90e4f284e72d296796fc446bbb1e2c7cc0530151" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 8016f2a611df1d603bc5f57f76e19ea3edd067758863be0221219c5d2879caff
[INFO] running `Command { std: "docker" "start" "8016f2a611df1d603bc5f57f76e19ea3edd067758863be0221219c5d2879caff", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-w" "/opt/rustwide/workdir" "--user" "0:0" "8016f2a611df1d603bc5f57f76e19ea3edd067758863be0221219c5d2879caff" "/opt/rustwide/cargo-home/bin/cargo" "+622891a4e29178280638a6b63a8908bde2c0c854" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "8016f2a611df1d603bc5f57f76e19ea3edd067758863be0221219c5d2879caff", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=" "-e" "RUSTDOCFLAGS=" "-w" "/opt/rustwide/workdir" "--user" "0:0" "8016f2a611df1d603bc5f57f76e19ea3edd067758863be0221219c5d2879caff" "/opt/rustwide/cargo-home/bin/cargo" "+622891a4e29178280638a6b63a8908bde2c0c854" "fix" "--allow-no-vcs" "--allow-dirty" "--frozen" "--all" "--all-targets" "--message-format=json" "-Zfix-edition=start=2015", kill_on_drop: false }`
[INFO] [stderr]    Compiling num-traits v0.2.19
[INFO] [stderr]     Checking finite-float-traits v0.1.0 (/opt/rustwide/workdir)
[INFO] [stdout] error[E0432]: unresolved import `checked_float`
[INFO] [stdout]   --> tests/tests_8_finite_rem_euclid.rs:17:5
[INFO] [stdout]    |
[INFO] [stdout] 17 | use checked_float::FiniteRemEuclid;
[INFO] [stdout]    |     ^^^^^^^^^^^^^ use of unresolved module or unlinked crate `checked_float`
[INFO] [stdout]    |
[INFO] [stdout]    = help: if you wanted to use a crate named `checked_float`, use `cargo add checked_float` to add it to your `Cargo.toml`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0432]: unresolved import `checked_float`
[INFO] [stdout]   --> tests/tests_7_finite_div_euclid.rs:17:5
[INFO] [stdout]    |
[INFO] [stdout] 17 | use checked_float::FiniteDivEuclid;
[INFO] [stdout]    |     ^^^^^^^^^^^^^ use of unresolved module or unlinked crate `checked_float`
[INFO] [stdout]    |
[INFO] [stdout]    = help: if you wanted to use a crate named `checked_float`, use `cargo add checked_float` to add it to your `Cargo.toml`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0432]: unresolved import `checked_float`
[INFO] [stdout]   --> tests/tests_2_finite_sub.rs:17:5
[INFO] [stdout]    |
[INFO] [stdout] 17 | use checked_float::FiniteSub;
[INFO] [stdout]    |     ^^^^^^^^^^^^^ use of unresolved module or unlinked crate `checked_float`
[INFO] [stdout]    |
[INFO] [stdout]    = help: if you wanted to use a crate named `checked_float`, use `cargo add checked_float` to add it to your `Cargo.toml`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0432]: unresolved import `checked_float`
[INFO] [stdout]   --> tests/tests_1_finite_add.rs:17:5
[INFO] [stdout]    |
[INFO] [stdout] 17 | use checked_float::FiniteAdd;
[INFO] [stdout]    |     ^^^^^^^^^^^^^ use of unresolved module or unlinked crate `checked_float`
[INFO] [stdout]    |
[INFO] [stdout]    = help: if you wanted to use a crate named `checked_float`, use `cargo add checked_float` to add it to your `Cargo.toml`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_7_finite_div_euclid.rs:21:17
[INFO] [stdout]    |
[INFO] [stdout] 21 |     assert_eq!(7.0.finite_div_euclid(3.0), Some(2.0));
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 21 |     assert_eq!(7.0_f32.finite_div_euclid(3.0), Some(2.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_7_finite_div_euclid.rs:26:17
[INFO] [stdout]    |
[INFO] [stdout] 26 |     assert_eq!(6.0.finite_div_euclid(2.0), Some(3.0));
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 26 |     assert_eq!(6.0_f32.finite_div_euclid(2.0), Some(3.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_7_finite_div_euclid.rs:31:17
[INFO] [stdout]    |
[INFO] [stdout] 31 |     assert_eq!(1.0.finite_div_euclid(0.0), None);
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 31 |     assert_eq!(1.0_f32.finite_div_euclid(0.0), None);
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_add` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_1_finite_add.rs:21:17
[INFO] [stdout]    |
[INFO] [stdout] 21 |     assert_eq!(1.0.finite_add(2.0), Some(3.0));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 21 |     assert_eq!(1.0_f32.finite_add(2.0), Some(3.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_sub` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_2_finite_sub.rs:21:17
[INFO] [stdout]    |
[INFO] [stdout] 21 |     assert_eq!(3.0.finite_sub(1.0), Some(2.0));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 21 |     assert_eq!(3.0_f32.finite_sub(1.0), Some(2.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0432]: unresolved import `checked_float`
[INFO] [stdout]   --> tests/tests_3_finite_mul.rs:17:5
[INFO] [stdout]    |
[INFO] [stdout] 17 | use checked_float::FiniteMul;
[INFO] [stdout]    |     ^^^^^^^^^^^^^ use of unresolved module or unlinked crate `checked_float`
[INFO] [stdout]    |
[INFO] [stdout]    = help: if you wanted to use a crate named `checked_float`, use `cargo add checked_float` to add it to your `Cargo.toml`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0432]: unresolved import `checked_float`
[INFO] [stdout]   --> tests/tests_6_finite_neg.rs:17:5
[INFO] [stdout]    |
[INFO] [stdout] 17 | use checked_float::FiniteNeg;
[INFO] [stdout]    |     ^^^^^^^^^^^^^ use of unresolved module or unlinked crate `checked_float`
[INFO] [stdout]    |
[INFO] [stdout]    = help: if you wanted to use a crate named `checked_float`, use `cargo add checked_float` to add it to your `Cargo.toml`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_sub` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_2_finite_sub.rs:26:17
[INFO] [stdout]    |
[INFO] [stdout] 26 |     assert_eq!(1.0.finite_sub(5.0), Some(-4.0));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 26 |     assert_eq!(1.0_f32.finite_sub(5.0), Some(-4.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_add` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_1_finite_add.rs:26:27
[INFO] [stdout]    |
[INFO] [stdout] 26 |     assert_eq!(f64::INFINITY.finite_add(1.0), None);
[INFO] [stdout]    |                              ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:18:5
[INFO] [stdout]    |
[INFO] [stdout] 18 |     fn finite_add(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteAdd` which provides `finite_add` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteAdd;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_div` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 26 -     assert_eq!(f64::INFINITY.finite_add(1.0), None);
[INFO] [stdout] 26 +     assert_eq!(f64::INFINITY.finite_div(1.0), None);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_add` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_1_finite_add.rs:31:31
[INFO] [stdout]    |
[INFO] [stdout] 31 |     assert_eq!(f64::NEG_INFINITY.finite_add(-1.0), None);
[INFO] [stdout]    |                                  ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:18:5
[INFO] [stdout]    |
[INFO] [stdout] 18 |     fn finite_add(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteAdd` which provides `finite_add` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteAdd;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_div` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 31 -     assert_eq!(f64::NEG_INFINITY.finite_add(-1.0), None);
[INFO] [stdout] 31 +     assert_eq!(f64::NEG_INFINITY.finite_div(-1.0), None);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_add` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_1_finite_add.rs:36:22
[INFO] [stdout]    |
[INFO] [stdout] 36 |     assert_eq!(f64::NAN.finite_add(1.0), None);
[INFO] [stdout]    |                         ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:18:5
[INFO] [stdout]    |
[INFO] [stdout] 18 |     fn finite_add(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteAdd` which provides `finite_add` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteAdd;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_div` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 36 -     assert_eq!(f64::NAN.finite_add(1.0), None);
[INFO] [stdout] 36 +     assert_eq!(f64::NAN.finite_div(1.0), None);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_add` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_1_finite_add.rs:41:17
[INFO] [stdout]    |
[INFO] [stdout] 41 |     assert_eq!(1.0.finite_add(f64::NAN), None);
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 41 |     assert_eq!(1.0_f32.finite_add(f64::NAN), None);
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_7_finite_div_euclid.rs:36:17
[INFO] [stdout]    |
[INFO] [stdout] 36 |     assert_eq!(0.0.finite_div_euclid(5.0), Some(0.0));
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 36 |     assert_eq!(0.0_f32.finite_div_euclid(5.0), Some(0.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_add` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_1_finite_add.rs:46:22
[INFO] [stdout]    |
[INFO] [stdout] 46 |     assert_eq!(f64::MAX.finite_add(f64::MAX), None);
[INFO] [stdout]    |                         ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:18:5
[INFO] [stdout]    |
[INFO] [stdout] 18 |     fn finite_add(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteAdd` which provides `finite_add` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteAdd;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_div` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 46 -     assert_eq!(f64::MAX.finite_add(f64::MAX), None);
[INFO] [stdout] 46 +     assert_eq!(f64::MAX.finite_div(f64::MAX), None);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_8_finite_rem_euclid.rs:21:17
[INFO] [stdout]    |
[INFO] [stdout] 21 |     assert_eq!(7.0.finite_rem_euclid(3.0), Some(1.0));
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 21 |     assert_eq!(7.0_f32.finite_rem_euclid(3.0), Some(1.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_add` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_1_finite_add.rs:51:22
[INFO] [stdout]    |
[INFO] [stdout] 51 |     assert_eq!(f64::MIN.finite_add(f64::MIN), None);
[INFO] [stdout]    |                         ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:18:5
[INFO] [stdout]    |
[INFO] [stdout] 18 |     fn finite_add(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteAdd` which provides `finite_add` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteAdd;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_div` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 51 -     assert_eq!(f64::MIN.finite_add(f64::MIN), None);
[INFO] [stdout] 51 +     assert_eq!(f64::MIN.finite_div(f64::MIN), None);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_add` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_1_finite_add.rs:56:22
[INFO] [stdout]    |
[INFO] [stdout] 56 |     assert_eq!(f64::MAX.finite_add(0.0), Some(f64::MAX));
[INFO] [stdout]    |                         ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:18:5
[INFO] [stdout]    |
[INFO] [stdout] 18 |     fn finite_add(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteAdd` which provides `finite_add` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteAdd;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_div` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 56 -     assert_eq!(f64::MAX.finite_add(0.0), Some(f64::MAX));
[INFO] [stdout] 56 +     assert_eq!(f64::MAX.finite_div(0.0), Some(f64::MAX));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_neg` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_6_finite_neg.rs:21:17
[INFO] [stdout]    |
[INFO] [stdout] 21 |     assert_eq!(1.0.finite_neg(), Some(-1.0));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 21 |     assert_eq!(1.0_f32.finite_neg(), Some(-1.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_add` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_1_finite_add.rs:61:17
[INFO] [stdout]    |
[INFO] [stdout] 61 |     assert_eq!(0.0.finite_add(5.0), Some(5.0));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 61 |     assert_eq!(0.0_f32.finite_add(5.0), Some(5.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0432]: unresolved import `checked_float`
[INFO] [stdout]   --> tests/tests_4_finite_div.rs:17:5
[INFO] [stdout]    |
[INFO] [stdout] 17 | use checked_float::FiniteDiv;
[INFO] [stdout]    |     ^^^^^^^^^^^^^ use of unresolved module or unlinked crate `checked_float`
[INFO] [stdout]    |
[INFO] [stdout]    = help: if you wanted to use a crate named `checked_float`, use `cargo add checked_float` to add it to your `Cargo.toml`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_add` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_1_finite_add.rs:66:23
[INFO] [stdout]    |
[INFO] [stdout] 66 |     assert_eq!((-0.0f64).finite_add(3.0), Some(3.0));
[INFO] [stdout]    |                          ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:18:5
[INFO] [stdout]    |
[INFO] [stdout] 18 |     fn finite_add(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteAdd` which provides `finite_add` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteAdd;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_div` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 66 -     assert_eq!((-0.0f64).finite_add(3.0), Some(3.0));
[INFO] [stdout] 66 +     assert_eq!((-0.0f64).finite_div(3.0), Some(3.0));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_sub` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_2_finite_sub.rs:31:27
[INFO] [stdout]    |
[INFO] [stdout] 31 |     assert_eq!(f64::INFINITY.finite_sub(1.0), None);
[INFO] [stdout]    |                              ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:22:5
[INFO] [stdout]    |
[INFO] [stdout] 22 |     fn finite_sub(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteSub` which provides `finite_sub` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteSub;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 31 -     assert_eq!(f64::INFINITY.finite_sub(1.0), None);
[INFO] [stdout] 31 +     assert_eq!(f64::INFINITY.finite_mul(1.0), None);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_add` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_1_finite_add.rs:72:17
[INFO] [stdout]    |
[INFO] [stdout] 72 |     assert_eq!(sub.finite_add(sub), Some(sub + sub));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:18:5
[INFO] [stdout]    |
[INFO] [stdout] 18 |     fn finite_add(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteAdd` which provides `finite_add` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteAdd;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_div` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 72 -     assert_eq!(sub.finite_add(sub), Some(sub + sub));
[INFO] [stdout] 72 +     assert_eq!(sub.finite_div(sub), Some(sub + sub));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_add` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_1_finite_add.rs:78:17
[INFO] [stdout]    |
[INFO] [stdout] 78 |     assert_eq!(1.0.finite_add(sub), Some(1.0 + sub));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 78 |     assert_eq!(1.0_f32.finite_add(sub), Some(1.0 + sub));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_sub` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_2_finite_sub.rs:36:17
[INFO] [stdout]    |
[INFO] [stdout] 36 |     assert_eq!(1.0.finite_sub(f64::INFINITY), None);
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 36 |     assert_eq!(1.0_f32.finite_sub(f64::INFINITY), None);
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_8_finite_rem_euclid.rs:26:17
[INFO] [stdout]    |
[INFO] [stdout] 26 |     assert_eq!(6.0.finite_rem_euclid(2.0), Some(0.0));
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 26 |     assert_eq!(6.0_f32.finite_rem_euclid(2.0), Some(0.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_add` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_1_finite_add.rs:83:20
[INFO] [stdout]    |
[INFO] [stdout] 83 |     assert_eq!((-1.0).finite_add(-2.0), Some(-3.0));
[INFO] [stdout]    |                       ^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div_euclid` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_7_finite_div_euclid.rs:41:22
[INFO] [stdout]    |
[INFO] [stdout] 41 |     assert_eq!(f64::NAN.finite_div_euclid(1.0), None);
[INFO] [stdout]    |                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:42:5
[INFO] [stdout]    |
[INFO] [stdout] 42 |     fn finite_div_euclid(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ----------------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDivEuclid` which provides `finite_div_euclid` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteDivEuclid;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `div_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 41 -     assert_eq!(f64::NAN.finite_div_euclid(1.0), None);
[INFO] [stdout] 41 +     assert_eq!(f64::NAN.div_euclid(1.0), None);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_add` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_1_finite_add.rs:88:17
[INFO] [stdout]    |
[INFO] [stdout] 88 |     assert_eq!(5.0.finite_add(-3.0), Some(2.0));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 88 |     assert_eq!(5.0_f32.finite_add(-3.0), Some(2.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0432]: unresolved import `checked_float`
[INFO] [stdout]   --> tests/tests_5_finite_rem.rs:17:5
[INFO] [stdout]    |
[INFO] [stdout] 17 | use checked_float::FiniteRem;
[INFO] [stdout]    |     ^^^^^^^^^^^^^ use of unresolved module or unlinked crate `checked_float`
[INFO] [stdout]    |
[INFO] [stdout]    = help: if you wanted to use a crate named `checked_float`, use `cargo add checked_float` to add it to your `Cargo.toml`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_sub` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_2_finite_sub.rs:41:22
[INFO] [stdout]    |
[INFO] [stdout] 41 |     assert_eq!(f64::NAN.finite_sub(1.0), None);
[INFO] [stdout]    |                         ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:22:5
[INFO] [stdout]    |
[INFO] [stdout] 22 |     fn finite_sub(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteSub` which provides `finite_sub` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteSub;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 41 -     assert_eq!(f64::NAN.finite_sub(1.0), None);
[INFO] [stdout] 41 +     assert_eq!(f64::NAN.finite_mul(1.0), None);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_7_finite_div_euclid.rs:46:17
[INFO] [stdout]    |
[INFO] [stdout] 46 |     assert_eq!(1.0.finite_div_euclid(f64::NAN), None);
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 46 |     assert_eq!(1.0_f32.finite_div_euclid(f64::NAN), None);
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_add` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_1_finite_add.rs:93:20
[INFO] [stdout]    |
[INFO] [stdout] 93 |     assert_eq!((-3.0).finite_add(5.0), Some(2.0));
[INFO] [stdout]    |                       ^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_8_finite_rem_euclid.rs:31:17
[INFO] [stdout]    |
[INFO] [stdout] 31 |     assert_eq!(1.0.finite_rem_euclid(0.0), None);
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 31 |     assert_eq!(1.0_f32.finite_rem_euclid(0.0), None);
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_neg` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_6_finite_neg.rs:26:20
[INFO] [stdout]    |
[INFO] [stdout] 26 |     assert_eq!((-2.5).finite_neg(), Some(2.5));
[INFO] [stdout]    |                       ^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_add` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_1_finite_add.rs:100:15
[INFO] [stdout]     |
[INFO] [stdout] 100 |     assert_eq!(a.finite_add(b), b.finite_add(a));
[INFO] [stdout]     |                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a type for this binding, like `f32`
[INFO] [stdout]     |
[INFO] [stdout]  98 |     let a: f32 = 1.5;
[INFO] [stdout]     |          +++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_sub` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_2_finite_sub.rs:46:17
[INFO] [stdout]    |
[INFO] [stdout] 46 |     assert_eq!(1.0.finite_sub(f64::NAN), None);
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 46 |     assert_eq!(1.0_f32.finite_sub(f64::NAN), None);
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_add` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_1_finite_add.rs:100:32
[INFO] [stdout]     |
[INFO] [stdout] 100 |     assert_eq!(a.finite_add(b), b.finite_add(a));
[INFO] [stdout]     |                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a type for this binding, like `f32`
[INFO] [stdout]     |
[INFO] [stdout]  99 |     let b: f32 = 2.5;
[INFO] [stdout]     |          +++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_mul` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_3_finite_mul.rs:21:17
[INFO] [stdout]    |
[INFO] [stdout] 21 |     assert_eq!(2.0.finite_mul(3.0), Some(6.0));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 21 |     assert_eq!(2.0_f32.finite_mul(3.0), Some(6.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_add` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_1_finite_add.rs:106:17
[INFO] [stdout]     |
[INFO] [stdout] 106 |     assert_eq!(min.finite_add(min), Some(min + min));
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:18:5
[INFO] [stdout]     |
[INFO] [stdout]  18 |     fn finite_add(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteAdd` which provides `finite_add` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteAdd;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_div` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 106 -     assert_eq!(min.finite_add(min), Some(min + min));
[INFO] [stdout] 106 +     assert_eq!(min.finite_div(min), Some(min + min));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div_euclid` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_7_finite_div_euclid.rs:51:27
[INFO] [stdout]    |
[INFO] [stdout] 51 |     assert_eq!(f64::INFINITY.finite_div_euclid(2.0), None);
[INFO] [stdout]    |                              ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:42:5
[INFO] [stdout]    |
[INFO] [stdout] 42 |     fn finite_div_euclid(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ----------------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDivEuclid` which provides `finite_div_euclid` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteDivEuclid;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `div_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 51 -     assert_eq!(f64::INFINITY.finite_div_euclid(2.0), None);
[INFO] [stdout] 51 +     assert_eq!(f64::INFINITY.div_euclid(2.0), None);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_8_finite_rem_euclid.rs:36:17
[INFO] [stdout]    |
[INFO] [stdout] 36 |     assert_eq!(0.0.finite_rem_euclid(5.0), Some(0.0));
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 36 |     assert_eq!(0.0_f32.finite_rem_euclid(5.0), Some(0.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_add` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_1_finite_add.rs:111:17
[INFO] [stdout]     |
[INFO] [stdout] 111 |     assert_eq!(0.5.finite_add(0.5), Some(1.0));
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 111 |     assert_eq!(0.5_f32.finite_add(0.5), Some(1.0));
[INFO] [stdout]     |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_sub` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_2_finite_sub.rs:51:22
[INFO] [stdout]    |
[INFO] [stdout] 51 |     assert_eq!(f64::MIN.finite_sub(f64::MAX), None);
[INFO] [stdout]    |                         ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:22:5
[INFO] [stdout]    |
[INFO] [stdout] 22 |     fn finite_sub(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteSub` which provides `finite_sub` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteSub;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 51 -     assert_eq!(f64::MIN.finite_sub(f64::MAX), None);
[INFO] [stdout] 51 +     assert_eq!(f64::MIN.finite_mul(f64::MAX), None);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_add` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_1_finite_add.rs:117:18
[INFO] [stdout]     |
[INFO] [stdout] 117 |     assert_eq!(tiny.finite_add(tiny), Some(2e-300));
[INFO] [stdout]     |                     ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a type for this binding, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 116 |     let tiny: f32 = 1e-300;
[INFO] [stdout]     |             +++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_neg` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_6_finite_neg.rs:31:17
[INFO] [stdout]    |
[INFO] [stdout] 31 |     assert_eq!(0.0.finite_neg(), Some(-0.0));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 31 |     assert_eq!(0.0_f32.finite_neg(), Some(-0.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_7_finite_div_euclid.rs:56:17
[INFO] [stdout]    |
[INFO] [stdout] 56 |     assert_eq!(1.0.finite_div_euclid(f64::INFINITY), Some(0.0));
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 56 |     assert_eq!(1.0_f32.finite_div_euclid(f64::INFINITY), Some(0.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_add` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_1_finite_add.rs:122:22
[INFO] [stdout]     |
[INFO] [stdout] 122 |     assert_eq!(f64::MIN.finite_add(1.0), Some(f64::MIN + 1.0));
[INFO] [stdout]     |                         ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:18:5
[INFO] [stdout]     |
[INFO] [stdout]  18 |     fn finite_add(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteAdd` which provides `finite_add` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteAdd;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_div` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 122 -     assert_eq!(f64::MIN.finite_add(1.0), Some(f64::MIN + 1.0));
[INFO] [stdout] 122 +     assert_eq!(f64::MIN.finite_div(1.0), Some(f64::MIN + 1.0));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_add` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_1_finite_add.rs:127:19
[INFO] [stdout]     |
[INFO] [stdout] 127 |     assert_eq!(1e200.finite_add(-1e200), Some(0.0));
[INFO] [stdout]     |                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 127 |     assert_eq!(1e200_f32.finite_add(-1e200), Some(0.0));
[INFO] [stdout]     |                     ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_sub` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_2_finite_sub.rs:56:22
[INFO] [stdout]    |
[INFO] [stdout] 56 |     assert_eq!(f64::MAX.finite_sub(f64::MIN), None);
[INFO] [stdout]    |                         ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:22:5
[INFO] [stdout]    |
[INFO] [stdout] 22 |     fn finite_sub(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteSub` which provides `finite_sub` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteSub;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 56 -     assert_eq!(f64::MAX.finite_sub(f64::MIN), None);
[INFO] [stdout] 56 +     assert_eq!(f64::MAX.finite_mul(f64::MIN), None);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `finite-float-traits` (test "tests_1_finite_add") due to 31 previous errors
[INFO] [stdout] error[E0599]: no method named `finite_add` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_1_finite_add.rs:134:15
[INFO] [stdout]     |
[INFO] [stdout] 134 |     assert_eq!(a.finite_add(b), Some(0.0));
[INFO] [stdout]     |                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:18:5
[INFO] [stdout]     |
[INFO] [stdout]  18 |     fn finite_add(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteAdd` which provides `finite_add` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteAdd;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_div` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 134 -     assert_eq!(a.finite_add(b), Some(0.0));
[INFO] [stdout] 134 +     assert_eq!(a.finite_div(b), Some(0.0));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error[E0689]: can't call method `finite_div_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_7_finite_div_euclid.rs:61:20
[INFO] [stdout]    |
[INFO] [stdout] 61 |     assert_eq!((-7.0).finite_div_euclid(3.0), Some(-3.0));
[INFO] [stdout]    |                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_add` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_1_finite_add.rs:141:15
[INFO] [stdout]     |
[INFO] [stdout] 141 |     assert_eq!(a.finite_add(b), Some(a));
[INFO] [stdout]     |                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:18:5
[INFO] [stdout]     |
[INFO] [stdout]  18 |     fn finite_add(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteAdd` which provides `finite_add` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteAdd;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_div` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 141 -     assert_eq!(a.finite_add(b), Some(a));
[INFO] [stdout] 141 +     assert_eq!(a.finite_div(b), Some(a));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_sub` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_2_finite_sub.rs:61:17
[INFO] [stdout]    |
[INFO] [stdout] 61 |     assert_eq!(0.0.finite_sub(5.0), Some(-5.0));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 61 |     assert_eq!(0.0_f32.finite_sub(5.0), Some(-5.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_add` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_1_finite_add.rs:148:15
[INFO] [stdout]     |
[INFO] [stdout] 148 |     assert!(near.finite_add(diff).is_some());
[INFO] [stdout]     |                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:18:5
[INFO] [stdout]     |
[INFO] [stdout]  18 |     fn finite_add(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteAdd` which provides `finite_add` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteAdd;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_div` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 148 -     assert!(near.finite_add(diff).is_some());
[INFO] [stdout] 148 +     assert!(near.finite_div(diff).is_some());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_mul` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_3_finite_mul.rs:26:17
[INFO] [stdout]    |
[INFO] [stdout] 26 |     assert_eq!(5.0.finite_mul(0.0), Some(0.0));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 26 |     assert_eq!(5.0_f32.finite_mul(0.0), Some(0.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_7_finite_div_euclid.rs:66:17
[INFO] [stdout]    |
[INFO] [stdout] 66 |     assert_eq!(7.0.finite_div_euclid(-3.0), Some(-2.0));
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 66 |     assert_eq!(7.0_f32.finite_div_euclid(-3.0), Some(-2.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_rem_euclid` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_8_finite_rem_euclid.rs:41:22
[INFO] [stdout]    |
[INFO] [stdout] 41 |     assert_eq!(f64::NAN.finite_rem_euclid(1.0), None);
[INFO] [stdout]    |                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:46:5
[INFO] [stdout]    |
[INFO] [stdout] 46 |     fn finite_rem_euclid(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ----------------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteRemEuclid` which provides `finite_rem_euclid` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteRemEuclid;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 41 -     assert_eq!(f64::NAN.finite_rem_euclid(1.0), None);
[INFO] [stdout] 41 +     assert_eq!(f64::NAN.finite_mul(1.0), None);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_add` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_1_finite_add.rs:153:22
[INFO] [stdout]     |
[INFO] [stdout] 153 |     assert_eq!(f64::MAX.finite_add(1.0), Some(f64::MAX));
[INFO] [stdout]     |                         ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:18:5
[INFO] [stdout]     |
[INFO] [stdout]  18 |     fn finite_add(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteAdd` which provides `finite_add` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteAdd;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_div` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 153 -     assert_eq!(f64::MAX.finite_add(1.0), Some(f64::MAX));
[INFO] [stdout] 153 +     assert_eq!(f64::MAX.finite_div(1.0), Some(f64::MAX));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_add` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_1_finite_add.rs:158:22
[INFO] [stdout]     |
[INFO] [stdout] 158 |     assert_eq!(f64::MIN.finite_add(-1.0), Some(f64::MIN));
[INFO] [stdout]     |                         ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:18:5
[INFO] [stdout]     |
[INFO] [stdout]  18 |     fn finite_add(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteAdd` which provides `finite_add` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteAdd;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_div` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 158 -     assert_eq!(f64::MIN.finite_add(-1.0), Some(f64::MIN));
[INFO] [stdout] 158 +     assert_eq!(f64::MIN.finite_div(-1.0), Some(f64::MIN));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_sub` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_2_finite_sub.rs:66:23
[INFO] [stdout]    |
[INFO] [stdout] 66 |     assert_eq!((-0.0f64).finite_sub(3.0), Some(-3.0));
[INFO] [stdout]    |                          ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:22:5
[INFO] [stdout]    |
[INFO] [stdout] 22 |     fn finite_sub(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteSub` which provides `finite_sub` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteSub;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 66 -     assert_eq!((-0.0f64).finite_sub(3.0), Some(-3.0));
[INFO] [stdout] 66 +     assert_eq!((-0.0f64).finite_mul(3.0), Some(-3.0));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_5_finite_rem.rs:21:17
[INFO] [stdout]    |
[INFO] [stdout] 21 |     assert_eq!(5.0.finite_rem(2.0), Some(1.0));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 21 |     assert_eq!(5.0_f32.finite_rem(2.0), Some(1.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_7_finite_div_euclid.rs:71:20
[INFO] [stdout]    |
[INFO] [stdout] 71 |     assert_eq!((-7.0).finite_div_euclid(-3.0), Some(3.0));
[INFO] [stdout]    |                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_add` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_1_finite_add.rs:165:17
[INFO] [stdout]     |
[INFO] [stdout] 165 |     assert_eq!(max.finite_add(sub), Some(max));
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:18:5
[INFO] [stdout]     |
[INFO] [stdout]  18 |     fn finite_add(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteAdd` which provides `finite_add` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteAdd;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_div` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 165 -     assert_eq!(max.finite_add(sub), Some(max));
[INFO] [stdout] 165 +     assert_eq!(max.finite_div(sub), Some(max));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_8_finite_rem_euclid.rs:46:17
[INFO] [stdout]    |
[INFO] [stdout] 46 |     assert_eq!(1.0.finite_rem_euclid(f64::NAN), None);
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 46 |     assert_eq!(1.0_f32.finite_rem_euclid(f64::NAN), None);
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_add` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_1_finite_add.rs:170:27
[INFO] [stdout]     |
[INFO] [stdout] 170 |     assert_eq!(f64::INFINITY.finite_add(2.0), None);
[INFO] [stdout]     |                              ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:18:5
[INFO] [stdout]     |
[INFO] [stdout]  18 |     fn finite_add(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteAdd` which provides `finite_add` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteAdd;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_div` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 170 -     assert_eq!(f64::INFINITY.finite_add(2.0), None);
[INFO] [stdout] 170 +     assert_eq!(f64::INFINITY.finite_div(2.0), None);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_sub` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_2_finite_sub.rs:72:17
[INFO] [stdout]    |
[INFO] [stdout] 72 |     assert_eq!(sub.finite_sub(sub), Some(0.0));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:22:5
[INFO] [stdout]    |
[INFO] [stdout] 22 |     fn finite_sub(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteSub` which provides `finite_sub` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteSub;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 72 -     assert_eq!(sub.finite_sub(sub), Some(0.0));
[INFO] [stdout] 72 +     assert_eq!(sub.finite_mul(sub), Some(0.0));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_add` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_1_finite_add.rs:175:22
[INFO] [stdout]     |
[INFO] [stdout] 175 |     assert_eq!(f64::NAN.finite_add(f64::NAN), None);
[INFO] [stdout]     |                         ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:18:5
[INFO] [stdout]     |
[INFO] [stdout]  18 |     fn finite_add(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteAdd` which provides `finite_add` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteAdd;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_div` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 175 -     assert_eq!(f64::NAN.finite_add(f64::NAN), None);
[INFO] [stdout] 175 +     assert_eq!(f64::NAN.finite_div(f64::NAN), None);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_7_finite_div_euclid.rs:76:17
[INFO] [stdout]    |
[INFO] [stdout] 76 |     assert_eq!(1.0.finite_div_euclid(3.0), Some(0.0));
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 76 |     assert_eq!(1.0_f32.finite_div_euclid(3.0), Some(0.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] Some errors have detailed explanations: E0432, E0599, E0689.
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_rem_euclid` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_8_finite_rem_euclid.rs:51:27
[INFO] [stdout]    |
[INFO] [stdout] 51 |     assert_eq!(f64::INFINITY.finite_rem_euclid(2.0), None);
[INFO] [stdout]    |                              ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:46:5
[INFO] [stdout]    |
[INFO] [stdout] 46 |     fn finite_rem_euclid(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ----------------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteRemEuclid` which provides `finite_rem_euclid` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteRemEuclid;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 51 -     assert_eq!(f64::INFINITY.finite_rem_euclid(2.0), None);
[INFO] [stdout] 51 +     assert_eq!(f64::INFINITY.finite_mul(2.0), None);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0432`.
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_5_finite_rem.rs:26:17
[INFO] [stdout]    |
[INFO] [stdout] 26 |     assert_eq!(6.0.finite_rem(3.0), Some(0.0));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 26 |     assert_eq!(6.0_f32.finite_rem(3.0), Some(0.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_sub` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_2_finite_sub.rs:78:17
[INFO] [stdout]    |
[INFO] [stdout] 78 |     assert_eq!(1.0.finite_sub(sub), Some(1.0 - sub));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 78 |     assert_eq!(1.0_f32.finite_sub(sub), Some(1.0 - sub));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_7_finite_div_euclid.rs:81:17
[INFO] [stdout]    |
[INFO] [stdout] 81 |     assert_eq!(3.0.finite_div_euclid(1.0), Some(3.0));
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 81 |     assert_eq!(3.0_f32.finite_div_euclid(1.0), Some(3.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_8_finite_rem_euclid.rs:56:17
[INFO] [stdout]    |
[INFO] [stdout] 56 |     assert_eq!(1.0.finite_rem_euclid(f64::INFINITY), Some(1.0));
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 56 |     assert_eq!(1.0_f32.finite_rem_euclid(f64::INFINITY), Some(1.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_5_finite_rem.rs:31:17
[INFO] [stdout]    |
[INFO] [stdout] 31 |     assert_eq!(1.0.finite_rem(0.0), None);
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 31 |     assert_eq!(1.0_f32.finite_rem(0.0), None);
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_neg` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_6_finite_neg.rs:36:23
[INFO] [stdout]    |
[INFO] [stdout] 36 |     assert_eq!((-0.0f64).finite_neg(), Some(0.0));
[INFO] [stdout]    |                          ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:38:5
[INFO] [stdout]    |
[INFO] [stdout] 38 |     fn finite_neg(&self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: there is a method `finite_rem` with a similar name, but with different arguments
[INFO] [stdout]   --> src/lib.rs:34:2
[INFO] [stdout]    |
[INFO] [stdout] 34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: trait `FiniteNeg` which provides `finite_neg` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteNeg;
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_sub` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_2_finite_sub.rs:83:20
[INFO] [stdout]    |
[INFO] [stdout] 83 |     assert_eq!((-1.0).finite_sub(-2.0), Some(1.0));
[INFO] [stdout]    |                       ^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_mul` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_3_finite_mul.rs:31:22
[INFO] [stdout]    |
[INFO] [stdout] 31 |     assert_eq!(f64::MAX.finite_mul(1.0), Some(f64::MAX));
[INFO] [stdout]    |                         ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:26:5
[INFO] [stdout]    |
[INFO] [stdout] 26 |     fn finite_mul(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteMul` which provides `finite_mul` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteMul;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 31 -     assert_eq!(f64::MAX.finite_mul(1.0), Some(f64::MAX));
[INFO] [stdout] 31 +     assert_eq!(f64::MAX.finite_rem_euclid(1.0), Some(f64::MAX));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div_euclid` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_7_finite_div_euclid.rs:86:22
[INFO] [stdout]    |
[INFO] [stdout] 86 |     assert_eq!(f64::MAX.finite_div_euclid(0.5), None);
[INFO] [stdout]    |                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:42:5
[INFO] [stdout]    |
[INFO] [stdout] 42 |     fn finite_div_euclid(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ----------------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDivEuclid` which provides `finite_div_euclid` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteDivEuclid;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `div_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 86 -     assert_eq!(f64::MAX.finite_div_euclid(0.5), None);
[INFO] [stdout] 86 +     assert_eq!(f64::MAX.div_euclid(0.5), None);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_8_finite_rem_euclid.rs:61:20
[INFO] [stdout]    |
[INFO] [stdout] 61 |     assert_eq!((-7.0).finite_rem_euclid(3.0), Some(2.0));
[INFO] [stdout]    |                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_neg` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_6_finite_neg.rs:41:27
[INFO] [stdout]    |
[INFO] [stdout] 41 |     assert_eq!(f64::INFINITY.finite_neg(), None);
[INFO] [stdout]    |                              ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:38:5
[INFO] [stdout]    |
[INFO] [stdout] 38 |     fn finite_neg(&self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: there is a method `finite_rem` with a similar name, but with different arguments
[INFO] [stdout]   --> src/lib.rs:34:2
[INFO] [stdout]    |
[INFO] [stdout] 34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: trait `FiniteNeg` which provides `finite_neg` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteNeg;
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_5_finite_rem.rs:36:17
[INFO] [stdout]    |
[INFO] [stdout] 36 |     assert_eq!(0.0.finite_rem(5.0), Some(0.0));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 36 |     assert_eq!(0.0_f32.finite_rem(5.0), Some(0.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_sub` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_2_finite_sub.rs:88:17
[INFO] [stdout]    |
[INFO] [stdout] 88 |     assert_eq!(5.0.finite_sub(-3.0), Some(8.0));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 88 |     assert_eq!(5.0_f32.finite_sub(-3.0), Some(8.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div_euclid` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_7_finite_div_euclid.rs:91:22
[INFO] [stdout]    |
[INFO] [stdout] 91 |     assert_eq!(f64::MIN.finite_div_euclid(0.5), None);
[INFO] [stdout]    |                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:42:5
[INFO] [stdout]    |
[INFO] [stdout] 42 |     fn finite_div_euclid(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ----------------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDivEuclid` which provides `finite_div_euclid` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteDivEuclid;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `div_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 91 -     assert_eq!(f64::MIN.finite_div_euclid(0.5), None);
[INFO] [stdout] 91 +     assert_eq!(f64::MIN.div_euclid(0.5), None);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_8_finite_rem_euclid.rs:66:17
[INFO] [stdout]    |
[INFO] [stdout] 66 |     assert_eq!(7.0.finite_rem_euclid(-3.0), Some(1.0));
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 66 |     assert_eq!(7.0_f32.finite_rem_euclid(-3.0), Some(1.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_sub` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_2_finite_sub.rs:93:19
[INFO] [stdout]    |
[INFO] [stdout] 93 |     assert_eq!(1e300.finite_sub(1e200), Some(1e300 - 1e200));
[INFO] [stdout]    |                      ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 93 |     assert_eq!(1e300_f32.finite_sub(1e200), Some(1e300 - 1e200));
[INFO] [stdout]    |                     ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_mul` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_3_finite_mul.rs:36:20
[INFO] [stdout]    |
[INFO] [stdout] 36 |     assert_eq!((-4.0).finite_mul(3.0), Some(-12.0));
[INFO] [stdout]    |                       ^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_4_finite_div.rs:21:17
[INFO] [stdout]    |
[INFO] [stdout] 21 |     assert_eq!(6.0.finite_div(2.0), Some(3.0));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 21 |     assert_eq!(6.0_f32.finite_div(2.0), Some(3.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div_euclid` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_7_finite_div_euclid.rs:96:22
[INFO] [stdout]    |
[INFO] [stdout] 96 |     assert_eq!(f64::MAX.finite_div_euclid(1.0), Some(f64::MAX));
[INFO] [stdout]    |                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:42:5
[INFO] [stdout]    |
[INFO] [stdout] 42 |     fn finite_div_euclid(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ----------------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDivEuclid` which provides `finite_div_euclid` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteDivEuclid;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `div_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 96 -     assert_eq!(f64::MAX.finite_div_euclid(1.0), Some(f64::MAX));
[INFO] [stdout] 96 +     assert_eq!(f64::MAX.div_euclid(1.0), Some(f64::MAX));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_neg` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_6_finite_neg.rs:46:31
[INFO] [stdout]    |
[INFO] [stdout] 46 |     assert_eq!(f64::NEG_INFINITY.finite_neg(), None);
[INFO] [stdout]    |                                  ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:38:5
[INFO] [stdout]    |
[INFO] [stdout] 38 |     fn finite_neg(&self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: there is a method `finite_rem` with a similar name, but with different arguments
[INFO] [stdout]   --> src/lib.rs:34:2
[INFO] [stdout]    |
[INFO] [stdout] 34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: trait `FiniteNeg` which provides `finite_neg` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteNeg;
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_8_finite_rem_euclid.rs:71:20
[INFO] [stdout]    |
[INFO] [stdout] 71 |     assert_eq!((-7.0).finite_rem_euclid(-3.0), Some(2.0));
[INFO] [stdout]    |                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_sub` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_2_finite_sub.rs:98:19
[INFO] [stdout]    |
[INFO] [stdout] 98 |     assert_eq!(1e200.finite_sub(1e200), Some(0.0));
[INFO] [stdout]    |                      ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 98 |     assert_eq!(1e200_f32.finite_sub(1e200), Some(0.0));
[INFO] [stdout]    |                     ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_rem` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_5_finite_rem.rs:41:22
[INFO] [stdout]    |
[INFO] [stdout] 41 |     assert_eq!(f64::NAN.finite_rem(1.0), None);
[INFO] [stdout]    |                         ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:34:5
[INFO] [stdout]    |
[INFO] [stdout] 34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteRem` which provides `finite_rem` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteRem;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 41 |     assert_eq!(f64::NAN.finite_rem_euclid(1.0), None);
[INFO] [stdout]    |                                   +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div_euclid` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_7_finite_div_euclid.rs:101:22
[INFO] [stdout]     |
[INFO] [stdout] 101 |     assert_eq!(f64::MIN.finite_div_euclid(1.0), Some(f64::MIN));
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:42:5
[INFO] [stdout]     |
[INFO] [stdout]  42 |     fn finite_div_euclid(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ----------------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDivEuclid` which provides `finite_div_euclid` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteDivEuclid;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `div_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 101 -     assert_eq!(f64::MIN.finite_div_euclid(1.0), Some(f64::MIN));
[INFO] [stdout] 101 +     assert_eq!(f64::MIN.div_euclid(1.0), Some(f64::MIN));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_mul` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_3_finite_mul.rs:41:20
[INFO] [stdout]    |
[INFO] [stdout] 41 |     assert_eq!((-4.0).finite_mul(-3.0), Some(12.0));
[INFO] [stdout]    |                       ^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_sub` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_2_finite_sub.rs:105:12
[INFO] [stdout]     |
[INFO] [stdout] 105 |     assert!(a.finite_sub(b).is_some());
[INFO] [stdout]     |               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a type for this binding, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 103 |     let a: f32 = 1.0;
[INFO] [stdout]     |          +++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_rem_euclid` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_8_finite_rem_euclid.rs:78:15
[INFO] [stdout]    |
[INFO] [stdout] 78 |     assert_eq!(a.finite_rem_euclid(b), Some(a.rem_euclid(b)));
[INFO] [stdout]    |                  ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:46:5
[INFO] [stdout]    |
[INFO] [stdout] 46 |     fn finite_rem_euclid(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ----------------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteRemEuclid` which provides `finite_rem_euclid` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteRemEuclid;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 78 -     assert_eq!(a.finite_rem_euclid(b), Some(a.rem_euclid(b)));
[INFO] [stdout] 78 +     assert_eq!(a.finite_mul(b), Some(a.rem_euclid(b)));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_5_finite_rem.rs:46:17
[INFO] [stdout]    |
[INFO] [stdout] 46 |     assert_eq!(1.0.finite_rem(f64::NAN), None);
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 46 |     assert_eq!(1.0_f32.finite_rem(f64::NAN), None);
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_neg` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_6_finite_neg.rs:51:22
[INFO] [stdout]    |
[INFO] [stdout] 51 |     assert_eq!(f64::NAN.finite_neg(), None);
[INFO] [stdout]    |                         ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:38:5
[INFO] [stdout]    |
[INFO] [stdout] 38 |     fn finite_neg(&self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: there is a method `finite_rem` with a similar name, but with different arguments
[INFO] [stdout]   --> src/lib.rs:34:2
[INFO] [stdout]    |
[INFO] [stdout] 34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: trait `FiniteNeg` which provides `finite_neg` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteNeg;
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_mul` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_3_finite_mul.rs:46:27
[INFO] [stdout]    |
[INFO] [stdout] 46 |     assert_eq!(f64::INFINITY.finite_mul(2.0), None);
[INFO] [stdout]    |                              ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:26:5
[INFO] [stdout]    |
[INFO] [stdout] 26 |     fn finite_mul(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteMul` which provides `finite_mul` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteMul;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 46 -     assert_eq!(f64::INFINITY.finite_mul(2.0), None);
[INFO] [stdout] 46 +     assert_eq!(f64::INFINITY.finite_rem_euclid(2.0), None);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div_euclid` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_7_finite_div_euclid.rs:106:22
[INFO] [stdout]     |
[INFO] [stdout] 106 |     assert_eq!(f64::MAX.finite_div_euclid(-1.0), Some(-f64::MAX));
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:42:5
[INFO] [stdout]     |
[INFO] [stdout]  42 |     fn finite_div_euclid(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ----------------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDivEuclid` which provides `finite_div_euclid` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteDivEuclid;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `div_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 106 -     assert_eq!(f64::MAX.finite_div_euclid(-1.0), Some(-f64::MAX));
[INFO] [stdout] 106 +     assert_eq!(f64::MAX.div_euclid(-1.0), Some(-f64::MAX));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_sub` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_2_finite_sub.rs:110:22
[INFO] [stdout]     |
[INFO] [stdout] 110 |     assert_eq!(f64::MAX.finite_sub(0.0), Some(f64::MAX));
[INFO] [stdout]     |                         ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:22:5
[INFO] [stdout]     |
[INFO] [stdout]  22 |     fn finite_sub(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteSub` which provides `finite_sub` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteSub;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 110 -     assert_eq!(f64::MAX.finite_sub(0.0), Some(f64::MAX));
[INFO] [stdout] 110 +     assert_eq!(f64::MAX.finite_mul(0.0), Some(f64::MAX));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_4_finite_div.rs:26:17
[INFO] [stdout]    |
[INFO] [stdout] 26 |     assert_eq!(1.0.finite_div(0.0), None);
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 26 |     assert_eq!(1.0_f32.finite_div(0.0), None);
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_8_finite_rem_euclid.rs:83:20
[INFO] [stdout]    |
[INFO] [stdout] 83 |     assert_eq!(1e-300.finite_rem_euclid(1.0), Some(1e-300));
[INFO] [stdout]    |                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 83 |     assert_eq!(1e-300_f32.finite_rem_euclid(1.0), Some(1e-300));
[INFO] [stdout]    |                      ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_rem` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_5_finite_rem.rs:51:27
[INFO] [stdout]    |
[INFO] [stdout] 51 |     assert_eq!(f64::INFINITY.finite_rem(1.0), None);
[INFO] [stdout]    |                              ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:34:5
[INFO] [stdout]    |
[INFO] [stdout] 34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteRem` which provides `finite_rem` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteRem;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 51 |     assert_eq!(f64::INFINITY.finite_rem_euclid(1.0), None);
[INFO] [stdout]    |                                        +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_4_finite_div.rs:31:17
[INFO] [stdout]    |
[INFO] [stdout] 31 |     assert_eq!(0.0.finite_div(0.0), None);
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 31 |     assert_eq!(0.0_f32.finite_div(0.0), None);
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div_euclid` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_7_finite_div_euclid.rs:111:22
[INFO] [stdout]     |
[INFO] [stdout] 111 |     assert_eq!(f64::MIN.finite_div_euclid(-1.0), Some(f64::MAX));
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:42:5
[INFO] [stdout]     |
[INFO] [stdout]  42 |     fn finite_div_euclid(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ----------------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDivEuclid` which provides `finite_div_euclid` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteDivEuclid;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `div_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 111 -     assert_eq!(f64::MIN.finite_div_euclid(-1.0), Some(f64::MAX));
[INFO] [stdout] 111 +     assert_eq!(f64::MIN.div_euclid(-1.0), Some(f64::MAX));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_mul` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_3_finite_mul.rs:51:17
[INFO] [stdout]    |
[INFO] [stdout] 51 |     assert_eq!(2.0.finite_mul(f64::INFINITY), None);
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 51 |     assert_eq!(2.0_f32.finite_mul(f64::INFINITY), None);
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_8_finite_rem_euclid.rs:88:17
[INFO] [stdout]    |
[INFO] [stdout] 88 |     assert_eq!(1.0.finite_rem_euclid(1e-300), Some(8.963186528039712e-301));
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 88 |     assert_eq!(1.0_f32.finite_rem_euclid(1e-300), Some(8.963186528039712e-301));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_sub` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_2_finite_sub.rs:115:22
[INFO] [stdout]     |
[INFO] [stdout] 115 |     assert_eq!(f64::MIN.finite_sub(0.0), Some(f64::MIN));
[INFO] [stdout]     |                         ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:22:5
[INFO] [stdout]     |
[INFO] [stdout]  22 |     fn finite_sub(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteSub` which provides `finite_sub` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteSub;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 115 -     assert_eq!(f64::MIN.finite_sub(0.0), Some(f64::MIN));
[INFO] [stdout] 115 +     assert_eq!(f64::MIN.finite_mul(0.0), Some(f64::MIN));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_5_finite_rem.rs:56:17
[INFO] [stdout]    |
[INFO] [stdout] 56 |     assert_eq!(1.0.finite_rem(f64::INFINITY), Some(1.0));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 56 |     assert_eq!(1.0_f32.finite_rem(f64::INFINITY), Some(1.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_mul` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_3_finite_mul.rs:56:22
[INFO] [stdout]    |
[INFO] [stdout] 56 |     assert_eq!(f64::NAN.finite_mul(1.0), None);
[INFO] [stdout]    |                         ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:26:5
[INFO] [stdout]    |
[INFO] [stdout] 26 |     fn finite_mul(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteMul` which provides `finite_mul` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteMul;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 56 -     assert_eq!(f64::NAN.finite_mul(1.0), None);
[INFO] [stdout] 56 +     assert_eq!(f64::NAN.finite_rem_euclid(1.0), None);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div_euclid` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_7_finite_div_euclid.rs:116:31
[INFO] [stdout]     |
[INFO] [stdout] 116 |     assert_eq!(f64::from_bits(1).finite_div_euclid(1.0), Some(0.0));
[INFO] [stdout]     |                                  ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:42:5
[INFO] [stdout]     |
[INFO] [stdout]  42 |     fn finite_div_euclid(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ----------------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDivEuclid` which provides `finite_div_euclid` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteDivEuclid;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `div_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 116 -     assert_eq!(f64::from_bits(1).finite_div_euclid(1.0), Some(0.0));
[INFO] [stdout] 116 +     assert_eq!(f64::from_bits(1).div_euclid(1.0), Some(0.0));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_sub` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_2_finite_sub.rs:120:27
[INFO] [stdout]     |
[INFO] [stdout] 120 |     assert_eq!(f64::INFINITY.finite_sub(f64::INFINITY), None);
[INFO] [stdout]     |                              ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:22:5
[INFO] [stdout]     |
[INFO] [stdout]  22 |     fn finite_sub(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteSub` which provides `finite_sub` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteSub;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 120 -     assert_eq!(f64::INFINITY.finite_sub(f64::INFINITY), None);
[INFO] [stdout] 120 +     assert_eq!(f64::INFINITY.finite_mul(f64::INFINITY), None);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_8_finite_rem_euclid.rs:93:17
[INFO] [stdout]    |
[INFO] [stdout] 93 |     assert_eq!(1.0.finite_rem_euclid(3.0), Some(1.0));
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 93 |     assert_eq!(1.0_f32.finite_rem_euclid(3.0), Some(1.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_5_finite_rem.rs:61:20
[INFO] [stdout]    |
[INFO] [stdout] 61 |     assert_eq!((-5.0).finite_rem(2.0), Some(-1.0));
[INFO] [stdout]    |                       ^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_mul` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_3_finite_mul.rs:61:17
[INFO] [stdout]    |
[INFO] [stdout] 61 |     assert_eq!(1.0.finite_mul(f64::NAN), None);
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 61 |     assert_eq!(1.0_f32.finite_mul(f64::NAN), None);
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_sub` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_2_finite_sub.rs:125:31
[INFO] [stdout]     |
[INFO] [stdout] 125 |     assert_eq!(f64::NEG_INFINITY.finite_sub(f64::NEG_INFINITY), None);
[INFO] [stdout]     |                                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:22:5
[INFO] [stdout]     |
[INFO] [stdout]  22 |     fn finite_sub(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteSub` which provides `finite_sub` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteSub;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 125 -     assert_eq!(f64::NEG_INFINITY.finite_sub(f64::NEG_INFINITY), None);
[INFO] [stdout] 125 +     assert_eq!(f64::NEG_INFINITY.finite_mul(f64::NEG_INFINITY), None);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_7_finite_div_euclid.rs:121:17
[INFO] [stdout]     |
[INFO] [stdout] 121 |     assert_eq!(1.0.finite_div_euclid(f64::from_bits(1)), None);
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 121 |     assert_eq!(1.0_f32.finite_div_euclid(f64::from_bits(1)), None);
[INFO] [stdout]     |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_8_finite_rem_euclid.rs:98:17
[INFO] [stdout]    |
[INFO] [stdout] 98 |     assert_eq!(3.0.finite_rem_euclid(1.0), Some(0.0));
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 98 |     assert_eq!(3.0_f32.finite_rem_euclid(1.0), Some(0.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_4_finite_div.rs:36:27
[INFO] [stdout]    |
[INFO] [stdout] 36 |     assert_eq!(f64::INFINITY.finite_div(2.0), None);
[INFO] [stdout]    |                              ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:30:5
[INFO] [stdout]    |
[INFO] [stdout] 30 |     fn finite_div(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDiv` which provides `finite_div` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteDiv;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_div_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 36 |     assert_eq!(f64::INFINITY.finite_div_euclid(2.0), None);
[INFO] [stdout]    |                                        +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_5_finite_rem.rs:66:17
[INFO] [stdout]    |
[INFO] [stdout] 66 |     assert_eq!(5.0.finite_rem(-2.0), Some(1.0));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 66 |     assert_eq!(5.0_f32.finite_rem(-2.0), Some(1.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_mul` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_3_finite_mul.rs:66:22
[INFO] [stdout]    |
[INFO] [stdout] 66 |     assert_eq!(f64::MAX.finite_mul(2.0), None);
[INFO] [stdout]    |                         ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:26:5
[INFO] [stdout]    |
[INFO] [stdout] 26 |     fn finite_mul(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteMul` which provides `finite_mul` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteMul;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 66 -     assert_eq!(f64::MAX.finite_mul(2.0), None);
[INFO] [stdout] 66 +     assert_eq!(f64::MAX.finite_rem_euclid(2.0), None);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_sub` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_2_finite_sub.rs:130:22
[INFO] [stdout]     |
[INFO] [stdout] 130 |     assert_eq!(f64::MAX.finite_sub(-1.0), Some(f64::MAX));
[INFO] [stdout]     |                         ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:22:5
[INFO] [stdout]     |
[INFO] [stdout]  22 |     fn finite_sub(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteSub` which provides `finite_sub` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteSub;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 130 -     assert_eq!(f64::MAX.finite_sub(-1.0), Some(f64::MAX));
[INFO] [stdout] 130 +     assert_eq!(f64::MAX.finite_mul(-1.0), Some(f64::MAX));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_7_finite_div_euclid.rs:128:15
[INFO] [stdout]     |
[INFO] [stdout] 128 |     assert_eq!(a.finite_div_euclid(b), Some(1e100));
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a type for this binding, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 126 |     let a: f32 = 1e200;
[INFO] [stdout]     |          +++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_4_finite_div.rs:41:17
[INFO] [stdout]    |
[INFO] [stdout] 41 |     assert_eq!(1.0.finite_div(f64::INFINITY), Some(0.0));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 41 |     assert_eq!(1.0_f32.finite_div(f64::INFINITY), Some(0.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_rem_euclid` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_8_finite_rem_euclid.rs:103:31
[INFO] [stdout]     |
[INFO] [stdout] 103 |     assert_eq!(f64::from_bits(1).finite_rem_euclid(1.0), Some(f64::from_bits(1)));
[INFO] [stdout]     |                                  ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:46:5
[INFO] [stdout]     |
[INFO] [stdout]  46 |     fn finite_rem_euclid(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ----------------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteRemEuclid` which provides `finite_rem_euclid` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteRemEuclid;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 103 -     assert_eq!(f64::from_bits(1).finite_rem_euclid(1.0), Some(f64::from_bits(1)));
[INFO] [stdout] 103 +     assert_eq!(f64::from_bits(1).finite_mul(1.0), Some(f64::from_bits(1)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_5_finite_rem.rs:71:20
[INFO] [stdout]    |
[INFO] [stdout] 71 |     assert_eq!((-5.0).finite_rem(-2.0), Some(-1.0));
[INFO] [stdout]    |                       ^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_sub` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_2_finite_sub.rs:135:22
[INFO] [stdout]     |
[INFO] [stdout] 135 |     assert_eq!(f64::MIN.finite_sub(1.0), Some(f64::MIN - 1.0));
[INFO] [stdout]     |                         ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:22:5
[INFO] [stdout]     |
[INFO] [stdout]  22 |     fn finite_sub(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteSub` which provides `finite_sub` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteSub;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 135 -     assert_eq!(f64::MIN.finite_sub(1.0), Some(f64::MIN - 1.0));
[INFO] [stdout] 135 +     assert_eq!(f64::MIN.finite_mul(1.0), Some(f64::MIN - 1.0));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_7_finite_div_euclid.rs:133:20
[INFO] [stdout]     |
[INFO] [stdout] 133 |     assert_eq!(1e-200.finite_div_euclid(1.0), Some(0.0));
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 133 |     assert_eq!(1e-200_f32.finite_div_euclid(1.0), Some(0.0));
[INFO] [stdout]     |                      ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_mul` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_3_finite_mul.rs:71:22
[INFO] [stdout]    |
[INFO] [stdout] 71 |     assert_eq!(f64::MIN.finite_mul(2.0), None);
[INFO] [stdout]    |                         ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:26:5
[INFO] [stdout]    |
[INFO] [stdout] 26 |     fn finite_mul(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteMul` which provides `finite_mul` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteMul;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 71 -     assert_eq!(f64::MIN.finite_mul(2.0), None);
[INFO] [stdout] 71 +     assert_eq!(f64::MIN.finite_rem_euclid(2.0), None);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_8_finite_rem_euclid.rs:108:17
[INFO] [stdout]     |
[INFO] [stdout] 108 |     assert_eq!(1.0.finite_rem_euclid(f64::from_bits(1)), Some(0.0));
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 108 |     assert_eq!(1.0_f32.finite_rem_euclid(f64::from_bits(1)), Some(0.0));
[INFO] [stdout]     |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_4_finite_div.rs:46:22
[INFO] [stdout]    |
[INFO] [stdout] 46 |     assert_eq!(f64::NAN.finite_div(1.0), None);
[INFO] [stdout]    |                         ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:30:5
[INFO] [stdout]    |
[INFO] [stdout] 30 |     fn finite_div(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDiv` which provides `finite_div` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteDiv;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_div_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 46 |     assert_eq!(f64::NAN.finite_div_euclid(1.0), None);
[INFO] [stdout]    |                                   +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_5_finite_rem.rs:76:19
[INFO] [stdout]    |
[INFO] [stdout] 76 |     assert_eq!(1e300.finite_rem(1e200), Some(1e300 % 1e200));
[INFO] [stdout]    |                      ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 76 |     assert_eq!(1e300_f32.finite_rem(1e200), Some(1e300 % 1e200));
[INFO] [stdout]    |                     ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_sub` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_2_finite_sub.rs:140:17
[INFO] [stdout]     |
[INFO] [stdout] 140 |     assert_eq!(0.0.finite_sub(0.0), Some(0.0));
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 140 |     assert_eq!(0.0_f32.finite_sub(0.0), Some(0.0));
[INFO] [stdout]     |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_mul` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_3_finite_mul.rs:77:17
[INFO] [stdout]    |
[INFO] [stdout] 77 |     assert_eq!(sub.finite_mul(sub), Some(0.0));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:26:5
[INFO] [stdout]    |
[INFO] [stdout] 26 |     fn finite_mul(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteMul` which provides `finite_mul` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteMul;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 77 -     assert_eq!(sub.finite_mul(sub), Some(0.0));
[INFO] [stdout] 77 +     assert_eq!(sub.finite_rem_euclid(sub), Some(0.0));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_7_finite_div_euclid.rs:138:17
[INFO] [stdout]     |
[INFO] [stdout] 138 |     assert_eq!(2.0.finite_div_euclid(5.0), Some(0.0));
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 138 |     assert_eq!(2.0_f32.finite_div_euclid(5.0), Some(0.0));
[INFO] [stdout]     |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_5_finite_rem.rs:81:20
[INFO] [stdout]    |
[INFO] [stdout] 81 |     assert_eq!(1e-300.finite_rem(1.0), Some(1e-300));
[INFO] [stdout]    |                       ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 81 |     assert_eq!(1e-300_f32.finite_rem(1.0), Some(1e-300));
[INFO] [stdout]    |                      ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_4_finite_div.rs:51:17
[INFO] [stdout]    |
[INFO] [stdout] 51 |     assert_eq!(1.0.finite_div(f64::NAN), None);
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 51 |     assert_eq!(1.0_f32.finite_div(f64::NAN), None);
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_rem_euclid` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_8_finite_rem_euclid.rs:113:22
[INFO] [stdout]     |
[INFO] [stdout] 113 |     assert_eq!(f64::MAX.finite_rem_euclid(1.0), Some(0.0));
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:46:5
[INFO] [stdout]     |
[INFO] [stdout]  46 |     fn finite_rem_euclid(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ----------------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteRemEuclid` which provides `finite_rem_euclid` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteRemEuclid;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 113 -     assert_eq!(f64::MAX.finite_rem_euclid(1.0), Some(0.0));
[INFO] [stdout] 113 +     assert_eq!(f64::MAX.finite_mul(1.0), Some(0.0));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_sub` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_2_finite_sub.rs:145:23
[INFO] [stdout]     |
[INFO] [stdout] 145 |     assert_eq!((-0.0f64).finite_sub(-0.0), Some(0.0));
[INFO] [stdout]     |                          ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:22:5
[INFO] [stdout]     |
[INFO] [stdout]  22 |     fn finite_sub(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteSub` which provides `finite_sub` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteSub;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 145 -     assert_eq!((-0.0f64).finite_sub(-0.0), Some(0.0));
[INFO] [stdout] 145 +     assert_eq!((-0.0f64).finite_mul(-0.0), Some(0.0));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_7_finite_div_euclid.rs:143:20
[INFO] [stdout]     |
[INFO] [stdout] 143 |     assert_eq!((-2.0).finite_div_euclid(5.0), Some(-1.0));
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_mul` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_3_finite_mul.rs:83:17
[INFO] [stdout]    |
[INFO] [stdout] 83 |     assert_eq!(sub.finite_mul(1e-100), Some(sub * 1e-100));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:26:5
[INFO] [stdout]    |
[INFO] [stdout] 26 |     fn finite_mul(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteMul` which provides `finite_mul` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteMul;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 83 -     assert_eq!(sub.finite_mul(1e-100), Some(sub * 1e-100));
[INFO] [stdout] 83 +     assert_eq!(sub.finite_rem_euclid(1e-100), Some(sub * 1e-100));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_5_finite_rem.rs:86:17
[INFO] [stdout]    |
[INFO] [stdout] 86 |     assert_eq!(1.0.finite_rem(1e-300), Some(8.963186528039712e-301));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 86 |     assert_eq!(1.0_f32.finite_rem(1e-300), Some(8.963186528039712e-301));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_4_finite_div.rs:56:22
[INFO] [stdout]    |
[INFO] [stdout] 56 |     assert_eq!(f64::MAX.finite_div(1e-300), None);
[INFO] [stdout]    |                         ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:30:5
[INFO] [stdout]    |
[INFO] [stdout] 30 |     fn finite_div(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDiv` which provides `finite_div` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteDiv;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_div_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 56 |     assert_eq!(f64::MAX.finite_div_euclid(1e-300), None);
[INFO] [stdout]    |                                   +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_rem_euclid` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_8_finite_rem_euclid.rs:118:22
[INFO] [stdout]     |
[INFO] [stdout] 118 |     assert_eq!(f64::MIN.finite_rem_euclid(1.0), Some(0.0));
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:46:5
[INFO] [stdout]     |
[INFO] [stdout]  46 |     fn finite_rem_euclid(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ----------------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteRemEuclid` which provides `finite_rem_euclid` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteRemEuclid;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 118 -     assert_eq!(f64::MIN.finite_rem_euclid(1.0), Some(0.0));
[INFO] [stdout] 118 +     assert_eq!(f64::MIN.finite_mul(1.0), Some(0.0));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_7_finite_div_euclid.rs:148:17
[INFO] [stdout]     |
[INFO] [stdout] 148 |     assert_eq!(2.0.finite_div_euclid(-5.0), Some(0.0));
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 148 |     assert_eq!(2.0_f32.finite_div_euclid(-5.0), Some(0.0));
[INFO] [stdout]     |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_sub` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_2_finite_sub.rs:152:15
[INFO] [stdout]     |
[INFO] [stdout] 152 |     assert_eq!(a.finite_sub(b), Some(a - b));
[INFO] [stdout]     |                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:22:5
[INFO] [stdout]     |
[INFO] [stdout]  22 |     fn finite_sub(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteSub` which provides `finite_sub` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteSub;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 152 -     assert_eq!(a.finite_sub(b), Some(a - b));
[INFO] [stdout] 152 +     assert_eq!(a.finite_mul(b), Some(a - b));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_mul` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_3_finite_mul.rs:88:22
[INFO] [stdout]    |
[INFO] [stdout] 88 |     assert_eq!(f64::MAX.finite_mul(1.5), None);
[INFO] [stdout]    |                         ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:26:5
[INFO] [stdout]    |
[INFO] [stdout] 26 |     fn finite_mul(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteMul` which provides `finite_mul` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteMul;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 88 -     assert_eq!(f64::MAX.finite_mul(1.5), None);
[INFO] [stdout] 88 +     assert_eq!(f64::MAX.finite_rem_euclid(1.5), None);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_rem` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_5_finite_rem.rs:92:17
[INFO] [stdout]    |
[INFO] [stdout] 92 |     assert_eq!(sub.finite_rem(1.0), Some(sub));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:34:5
[INFO] [stdout]    |
[INFO] [stdout] 34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteRem` which provides `finite_rem` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteRem;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 92 |     assert_eq!(sub.finite_rem_euclid(1.0), Some(sub));
[INFO] [stdout]    |                              +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_4_finite_div.rs:61:31
[INFO] [stdout]    |
[INFO] [stdout] 61 |     assert_eq!(f64::MIN_POSITIVE.finite_div(1e300), Some(0.0));
[INFO] [stdout]    |                                  ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:30:5
[INFO] [stdout]    |
[INFO] [stdout] 30 |     fn finite_div(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDiv` which provides `finite_div` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteDiv;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_div_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 61 |     assert_eq!(f64::MIN_POSITIVE.finite_div_euclid(1e300), Some(0.0));
[INFO] [stdout]    |                                            +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_rem_euclid` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_8_finite_rem_euclid.rs:123:22
[INFO] [stdout]     |
[INFO] [stdout] 123 |     assert_eq!(f64::MAX.finite_rem_euclid(-1.0), Some(0.0));
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:46:5
[INFO] [stdout]     |
[INFO] [stdout]  46 |     fn finite_rem_euclid(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ----------------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteRemEuclid` which provides `finite_rem_euclid` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteRemEuclid;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 123 -     assert_eq!(f64::MAX.finite_rem_euclid(-1.0), Some(0.0));
[INFO] [stdout] 123 +     assert_eq!(f64::MAX.finite_mul(-1.0), Some(0.0));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_sub` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_2_finite_sub.rs:157:20
[INFO] [stdout]     |
[INFO] [stdout] 157 |     assert_eq!(1e-300.finite_sub(-1e300), Some(1e300 + 1e-300));
[INFO] [stdout]     |                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 157 |     assert_eq!(1e-300_f32.finite_sub(-1e300), Some(1e300 + 1e-300));
[INFO] [stdout]     |                      ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_7_finite_div_euclid.rs:153:22
[INFO] [stdout]     |
[INFO] [stdout] 153 |     assert_eq!((-1e300).finite_div_euclid(1e100), Some(-1e200));
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_mul` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_3_finite_mul.rs:93:22
[INFO] [stdout]    |
[INFO] [stdout] 93 |     assert_eq!(f64::MAX.finite_mul(-1.0), Some(f64::MIN));
[INFO] [stdout]    |                         ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:26:5
[INFO] [stdout]    |
[INFO] [stdout] 26 |     fn finite_mul(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteMul` which provides `finite_mul` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteMul;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 93 -     assert_eq!(f64::MAX.finite_mul(-1.0), Some(f64::MIN));
[INFO] [stdout] 93 +     assert_eq!(f64::MAX.finite_rem_euclid(-1.0), Some(f64::MIN));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_5_finite_rem.rs:98:17
[INFO] [stdout]    |
[INFO] [stdout] 98 |     assert_eq!(1.0.finite_rem(sub), Some(0.0));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 98 |     assert_eq!(1.0_f32.finite_rem(sub), Some(0.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_rem_euclid` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_8_finite_rem_euclid.rs:128:22
[INFO] [stdout]     |
[INFO] [stdout] 128 |     assert_eq!(f64::MIN.finite_rem_euclid(-1.0), Some(0.0));
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:46:5
[INFO] [stdout]     |
[INFO] [stdout]  46 |     fn finite_rem_euclid(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ----------------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteRemEuclid` which provides `finite_rem_euclid` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteRemEuclid;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 128 -     assert_eq!(f64::MIN.finite_rem_euclid(-1.0), Some(0.0));
[INFO] [stdout] 128 +     assert_eq!(f64::MIN.finite_mul(-1.0), Some(0.0));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_4_finite_div.rs:66:22
[INFO] [stdout]    |
[INFO] [stdout] 66 |     assert_eq!(f64::MIN.finite_div(1e-300), None);
[INFO] [stdout]    |                         ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:30:5
[INFO] [stdout]    |
[INFO] [stdout] 30 |     fn finite_div(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDiv` which provides `finite_div` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteDiv;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_div_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 66 |     assert_eq!(f64::MIN.finite_div_euclid(1e-300), None);
[INFO] [stdout]    |                                   +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div_euclid` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_7_finite_div_euclid.rs:158:23
[INFO] [stdout]     |
[INFO] [stdout] 158 |     assert_eq!((-0.0f64).finite_div_euclid(3.0), Some(0.0));
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:42:5
[INFO] [stdout]     |
[INFO] [stdout]  42 |     fn finite_div_euclid(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ----------------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDivEuclid` which provides `finite_div_euclid` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteDivEuclid;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `div_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 158 -     assert_eq!((-0.0f64).finite_div_euclid(3.0), Some(0.0));
[INFO] [stdout] 158 +     assert_eq!((-0.0f64).div_euclid(3.0), Some(0.0));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_sub` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_2_finite_sub.rs:162:22
[INFO] [stdout]     |
[INFO] [stdout] 162 |     assert_eq!(f64::MAX.finite_sub(f64::from_bits(1)), Some(f64::MAX));
[INFO] [stdout]     |                         ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:22:5
[INFO] [stdout]     |
[INFO] [stdout]  22 |     fn finite_sub(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteSub` which provides `finite_sub` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteSub;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 162 -     assert_eq!(f64::MAX.finite_sub(f64::from_bits(1)), Some(f64::MAX));
[INFO] [stdout] 162 +     assert_eq!(f64::MAX.finite_mul(f64::from_bits(1)), Some(f64::MAX));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_rem` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_5_finite_rem.rs:103:23
[INFO] [stdout]     |
[INFO] [stdout] 103 |     assert_eq!((-0.0f64).finite_rem(3.0), Some(-0.0));
[INFO] [stdout]     |                          ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:34:5
[INFO] [stdout]     |
[INFO] [stdout]  34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteRem` which provides `finite_rem` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteRem;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 103 |     assert_eq!((-0.0f64).finite_rem_euclid(3.0), Some(-0.0));
[INFO] [stdout]     |                                    +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_mul` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_3_finite_mul.rs:98:22
[INFO] [stdout]    |
[INFO] [stdout] 98 |     assert_eq!(f64::MIN.finite_mul(-1.0), Some(f64::MAX));
[INFO] [stdout]    |                         ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:26:5
[INFO] [stdout]    |
[INFO] [stdout] 26 |     fn finite_mul(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteMul` which provides `finite_mul` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteMul;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 98 -     assert_eq!(f64::MIN.finite_mul(-1.0), Some(f64::MAX));
[INFO] [stdout] 98 +     assert_eq!(f64::MIN.finite_rem_euclid(-1.0), Some(f64::MAX));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_4_finite_div.rs:71:22
[INFO] [stdout]    |
[INFO] [stdout] 71 |     assert_eq!(f64::MAX.finite_div(1.0), Some(f64::MAX));
[INFO] [stdout]    |                         ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:30:5
[INFO] [stdout]    |
[INFO] [stdout] 30 |     fn finite_div(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDiv` which provides `finite_div` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteDiv;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_div_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 71 |     assert_eq!(f64::MAX.finite_div_euclid(1.0), Some(f64::MAX));
[INFO] [stdout]    |                                   +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_7_finite_div_euclid.rs:163:17
[INFO] [stdout]     |
[INFO] [stdout] 163 |     assert_eq!(1.0.finite_div_euclid(-0.0), None);
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 163 |     assert_eq!(1.0_f32.finite_div_euclid(-0.0), None);
[INFO] [stdout]     |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_rem_euclid` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_8_finite_rem_euclid.rs:133:22
[INFO] [stdout]     |
[INFO] [stdout] 133 |     assert_eq!(f64::MAX.finite_rem_euclid(0.5), Some(0.0));
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:46:5
[INFO] [stdout]     |
[INFO] [stdout]  46 |     fn finite_rem_euclid(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ----------------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteRemEuclid` which provides `finite_rem_euclid` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteRemEuclid;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 133 -     assert_eq!(f64::MAX.finite_rem_euclid(0.5), Some(0.0));
[INFO] [stdout] 133 +     assert_eq!(f64::MAX.finite_mul(0.5), Some(0.0));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_sub` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_2_finite_sub.rs:167:27
[INFO] [stdout]     |
[INFO] [stdout] 167 |     assert_eq!(f64::INFINITY.finite_sub(10.0), None);
[INFO] [stdout]     |                              ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:22:5
[INFO] [stdout]     |
[INFO] [stdout]  22 |     fn finite_sub(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteSub` which provides `finite_sub` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteSub;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 167 -     assert_eq!(f64::INFINITY.finite_sub(10.0), None);
[INFO] [stdout] 167 +     assert_eq!(f64::INFINITY.finite_mul(10.0), None);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_neg` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_6_finite_neg.rs:56:22
[INFO] [stdout]    |
[INFO] [stdout] 56 |     assert_eq!(f64::MAX.finite_neg(), Some(f64::MIN));
[INFO] [stdout]    |                         ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:38:5
[INFO] [stdout]    |
[INFO] [stdout] 38 |     fn finite_neg(&self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: there is a method `finite_rem` with a similar name, but with different arguments
[INFO] [stdout]   --> src/lib.rs:34:2
[INFO] [stdout]    |
[INFO] [stdout] 34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: trait `FiniteNeg` which provides `finite_neg` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteNeg;
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_5_finite_rem.rs:108:17
[INFO] [stdout]     |
[INFO] [stdout] 108 |     assert_eq!(1.0.finite_rem(-0.0), None);
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 108 |     assert_eq!(1.0_f32.finite_rem(-0.0), None);
[INFO] [stdout]     |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_mul` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_3_finite_mul.rs:103:17
[INFO] [stdout]     |
[INFO] [stdout] 103 |     assert_eq!(0.0.finite_mul(f64::INFINITY), None);
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 103 |     assert_eq!(0.0_f32.finite_mul(f64::INFINITY), None);
[INFO] [stdout]     |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_sub` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_2_finite_sub.rs:172:18
[INFO] [stdout]     |
[INFO] [stdout] 172 |     assert_eq!(10.0.finite_sub(f64::NEG_INFINITY), None);
[INFO] [stdout]     |                     ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 172 |     assert_eq!(10.0_f32.finite_sub(f64::NEG_INFINITY), None);
[INFO] [stdout]     |                    ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_4_finite_div.rs:76:22
[INFO] [stdout]    |
[INFO] [stdout] 76 |     assert_eq!(f64::MIN.finite_div(1.0), Some(f64::MIN));
[INFO] [stdout]    |                         ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:30:5
[INFO] [stdout]    |
[INFO] [stdout] 30 |     fn finite_div(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDiv` which provides `finite_div` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteDiv;
[INFO] [stdout]    |
[INFO] [stdout] help: there is a method `finite_div_euclid` with a similar name
[INFO] [stdout]    |
[INFO] [stdout] 76 |     assert_eq!(f64::MIN.finite_div_euclid(1.0), Some(f64::MIN));
[INFO] [stdout]    |                                   +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div_euclid` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_7_finite_div_euclid.rs:168:27
[INFO] [stdout]     |
[INFO] [stdout] 168 |     assert_eq!(f64::INFINITY.finite_div_euclid(f64::INFINITY), None);
[INFO] [stdout]     |                              ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:42:5
[INFO] [stdout]     |
[INFO] [stdout]  42 |     fn finite_div_euclid(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ----------------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDivEuclid` which provides `finite_div_euclid` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteDivEuclid;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `div_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 168 -     assert_eq!(f64::INFINITY.finite_div_euclid(f64::INFINITY), None);
[INFO] [stdout] 168 +     assert_eq!(f64::INFINITY.div_euclid(f64::INFINITY), None);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_rem_euclid` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_8_finite_rem_euclid.rs:138:23
[INFO] [stdout]     |
[INFO] [stdout] 138 |     assert_eq!((-0.0f64).finite_rem_euclid(3.0), Some(0.0));
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:46:5
[INFO] [stdout]     |
[INFO] [stdout]  46 |     fn finite_rem_euclid(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ----------------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteRemEuclid` which provides `finite_rem_euclid` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteRemEuclid;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 138 -     assert_eq!((-0.0f64).finite_rem_euclid(3.0), Some(0.0));
[INFO] [stdout] 138 +     assert_eq!((-0.0f64).finite_mul(3.0), Some(0.0));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_rem` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_5_finite_rem.rs:113:22
[INFO] [stdout]     |
[INFO] [stdout] 113 |     assert_eq!(f64::MAX.finite_rem(1.0), Some(0.0));
[INFO] [stdout]     |                         ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:34:5
[INFO] [stdout]     |
[INFO] [stdout]  34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteRem` which provides `finite_rem` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteRem;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 113 |     assert_eq!(f64::MAX.finite_rem_euclid(1.0), Some(0.0));
[INFO] [stdout]     |                                   +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] Some errors have detailed explanations: E0432, E0599, E0689.
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0432`.
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_mul` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_3_finite_mul.rs:108:27
[INFO] [stdout]     |
[INFO] [stdout] 108 |     assert_eq!(f64::INFINITY.finite_mul(0.0), None);
[INFO] [stdout]     |                              ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:26:5
[INFO] [stdout]     |
[INFO] [stdout]  26 |     fn finite_mul(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteMul` which provides `finite_mul` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteMul;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 108 -     assert_eq!(f64::INFINITY.finite_mul(0.0), None);
[INFO] [stdout] 108 +     assert_eq!(f64::INFINITY.finite_rem_euclid(0.0), None);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] Some errors have detailed explanations: E0432, E0599, E0689.
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0432`.
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_8_finite_rem_euclid.rs:143:17
[INFO] [stdout]     |
[INFO] [stdout] 143 |     assert_eq!(1.0.finite_rem_euclid(-0.0), None);
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 143 |     assert_eq!(1.0_f32.finite_rem_euclid(-0.0), None);
[INFO] [stdout]     |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_neg` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_6_finite_neg.rs:61:22
[INFO] [stdout]    |
[INFO] [stdout] 61 |     assert_eq!(f64::MIN.finite_neg(), Some(f64::MAX));
[INFO] [stdout]    |                         ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:38:5
[INFO] [stdout]    |
[INFO] [stdout] 38 |     fn finite_neg(&self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: there is a method `finite_rem` with a similar name, but with different arguments
[INFO] [stdout]   --> src/lib.rs:34:2
[INFO] [stdout]    |
[INFO] [stdout] 34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: trait `FiniteNeg` which provides `finite_neg` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteNeg;
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `finite-float-traits` (test "tests_7_finite_div_euclid") due to 31 previous errors
[INFO] [stdout] error[E0689]: can't call method `finite_div` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_4_finite_div.rs:81:20
[INFO] [stdout]    |
[INFO] [stdout] 81 |     assert_eq!((-6.0).finite_div(-2.0), Some(3.0));
[INFO] [stdout]    |                       ^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_rem` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_5_finite_rem.rs:118:22
[INFO] [stdout]     |
[INFO] [stdout] 118 |     assert_eq!(f64::MAX.finite_rem(2.0), Some(f64::MAX % 2.0));
[INFO] [stdout]     |                         ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:34:5
[INFO] [stdout]     |
[INFO] [stdout]  34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteRem` which provides `finite_rem` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteRem;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 118 |     assert_eq!(f64::MAX.finite_rem_euclid(2.0), Some(f64::MAX % 2.0));
[INFO] [stdout]     |                                   +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_mul` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_3_finite_mul.rs:115:12
[INFO] [stdout]     |
[INFO] [stdout] 115 |     assert!(a.finite_mul(b).is_some());
[INFO] [stdout]     |               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a type for this binding, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 113 |     let a: f32 = 1e200;
[INFO] [stdout]     |          +++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_4_finite_div.rs:86:20
[INFO] [stdout]    |
[INFO] [stdout] 86 |     assert_eq!((-6.0).finite_div(2.0), Some(-3.0));
[INFO] [stdout]    |                       ^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `finite-float-traits` (test "tests_2_finite_sub") due to 31 previous errors
[INFO] [stdout] error[E0689]: can't call method `finite_rem_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_8_finite_rem_euclid.rs:148:20
[INFO] [stdout]     |
[INFO] [stdout] 148 |     assert_eq!((-5.0).finite_rem_euclid(3.0), Some(1.0));
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_neg` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_6_finite_neg.rs:67:17
[INFO] [stdout]    |
[INFO] [stdout] 67 |     assert_eq!(sub.finite_neg(), Some(-sub));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:38:5
[INFO] [stdout]    |
[INFO] [stdout] 38 |     fn finite_neg(&self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: there is a method `finite_rem` with a similar name, but with different arguments
[INFO] [stdout]   --> src/lib.rs:34:2
[INFO] [stdout]    |
[INFO] [stdout] 34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: trait `FiniteNeg` which provides `finite_neg` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteNeg;
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_mul` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_3_finite_mul.rs:120:17
[INFO] [stdout]     |
[INFO] [stdout] 120 |     assert_eq!(2.0.finite_mul(0.5), Some(1.0));
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 120 |     assert_eq!(2.0_f32.finite_mul(0.5), Some(1.0));
[INFO] [stdout]     |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_rem` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_5_finite_rem.rs:123:22
[INFO] [stdout]     |
[INFO] [stdout] 123 |     assert_eq!(f64::MIN.finite_rem(1.0), Some(-0.0));
[INFO] [stdout]     |                         ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:34:5
[INFO] [stdout]     |
[INFO] [stdout]  34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteRem` which provides `finite_rem` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteRem;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 123 |     assert_eq!(f64::MIN.finite_rem_euclid(1.0), Some(-0.0));
[INFO] [stdout]     |                                   +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_neg` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_6_finite_neg.rs:73:17
[INFO] [stdout]    |
[INFO] [stdout] 73 |     assert_eq!(sub.finite_neg(), Some(-sub));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:38:5
[INFO] [stdout]    |
[INFO] [stdout] 38 |     fn finite_neg(&self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: there is a method `finite_rem` with a similar name, but with different arguments
[INFO] [stdout]   --> src/lib.rs:34:2
[INFO] [stdout]    |
[INFO] [stdout] 34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: trait `FiniteNeg` which provides `finite_neg` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteNeg;
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_4_finite_div.rs:91:17
[INFO] [stdout]    |
[INFO] [stdout] 91 |     assert_eq!(0.0.finite_div(5.0), Some(0.0));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 91 |     assert_eq!(0.0_f32.finite_div(5.0), Some(0.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_8_finite_rem_euclid.rs:153:17
[INFO] [stdout]     |
[INFO] [stdout] 153 |     assert_eq!(5.0.finite_rem_euclid(-3.0), Some(2.0));
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 153 |     assert_eq!(5.0_f32.finite_rem_euclid(-3.0), Some(2.0));
[INFO] [stdout]     |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_neg` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_6_finite_neg.rs:78:17
[INFO] [stdout]    |
[INFO] [stdout] 78 |     assert_eq!(1.0.finite_neg(), Some(-1.0));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 78 |     assert_eq!(1.0_f32.finite_neg(), Some(-1.0));
[INFO] [stdout]    |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_rem` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_5_finite_rem.rs:128:22
[INFO] [stdout]     |
[INFO] [stdout] 128 |     assert_eq!(f64::MIN.finite_rem(-1.0), Some(-0.0));
[INFO] [stdout]     |                         ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:34:5
[INFO] [stdout]     |
[INFO] [stdout]  34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteRem` which provides `finite_rem` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteRem;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 128 |     assert_eq!(f64::MIN.finite_rem_euclid(-1.0), Some(-0.0));
[INFO] [stdout]     |                                   +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_mul` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_3_finite_mul.rs:125:31
[INFO] [stdout]     |
[INFO] [stdout] 125 |     assert_eq!(f64::from_bits(1).finite_mul(0.0), Some(0.0));
[INFO] [stdout]     |                                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:26:5
[INFO] [stdout]     |
[INFO] [stdout]  26 |     fn finite_mul(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteMul` which provides `finite_mul` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteMul;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 125 -     assert_eq!(f64::from_bits(1).finite_mul(0.0), Some(0.0));
[INFO] [stdout] 125 +     assert_eq!(f64::from_bits(1).finite_rem_euclid(0.0), Some(0.0));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_4_finite_div.rs:96:20
[INFO] [stdout]    |
[INFO] [stdout] 96 |     assert_eq!(1e-300.finite_div(1e300), Some(0.0));
[INFO] [stdout]    |                       ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 96 |     assert_eq!(1e-300_f32.finite_div(1e300), Some(0.0));
[INFO] [stdout]    |                      ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_8_finite_rem_euclid.rs:158:20
[INFO] [stdout]     |
[INFO] [stdout] 158 |     assert_eq!((-5.0).finite_rem_euclid(-3.0), Some(1.0));
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_rem` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_5_finite_rem.rs:133:27
[INFO] [stdout]     |
[INFO] [stdout] 133 |     assert_eq!(f64::INFINITY.finite_rem(f64::INFINITY), None);
[INFO] [stdout]     |                              ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:34:5
[INFO] [stdout]     |
[INFO] [stdout]  34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteRem` which provides `finite_rem` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteRem;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 133 |     assert_eq!(f64::INFINITY.finite_rem_euclid(f64::INFINITY), None);
[INFO] [stdout]     |                                        +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_rem_euclid` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_8_finite_rem_euclid.rs:165:15
[INFO] [stdout]     |
[INFO] [stdout] 165 |     assert_eq!(a.finite_rem_euclid(b), Some(a.rem_euclid(b)));
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:46:5
[INFO] [stdout]     |
[INFO] [stdout]  46 |     fn finite_rem_euclid(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ----------------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteRemEuclid` which provides `finite_rem_euclid` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteRemEuclid;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_mul` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 165 -     assert_eq!(a.finite_rem_euclid(b), Some(a.rem_euclid(b)));
[INFO] [stdout] 165 +     assert_eq!(a.finite_mul(b), Some(a.rem_euclid(b)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_neg` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_6_finite_neg.rs:83:30
[INFO] [stdout]    |
[INFO] [stdout] 83 |     assert_eq!(2.0_f64.powi(10).finite_neg(), Some(-1024.0));
[INFO] [stdout]    |                                 ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:38:5
[INFO] [stdout]    |
[INFO] [stdout] 38 |     fn finite_neg(&self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: there is a method `finite_rem` with a similar name, but with different arguments
[INFO] [stdout]   --> src/lib.rs:34:2
[INFO] [stdout]    |
[INFO] [stdout] 34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: trait `FiniteNeg` which provides `finite_neg` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteNeg;
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_neg` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_6_finite_neg.rs:89:17
[INFO] [stdout]    |
[INFO] [stdout] 89 |     assert_eq!(val.finite_neg(), Some(-1e300));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a type for this binding, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 88 |     let val: f32 = 1e300;
[INFO] [stdout]    |            +++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_rem` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_5_finite_rem.rs:138:31
[INFO] [stdout]     |
[INFO] [stdout] 138 |     assert_eq!(f64::NEG_INFINITY.finite_rem(2.0), None);
[INFO] [stdout]     |                                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:34:5
[INFO] [stdout]     |
[INFO] [stdout]  34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteRem` which provides `finite_rem` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteRem;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 138 |     assert_eq!(f64::NEG_INFINITY.finite_rem_euclid(2.0), None);
[INFO] [stdout]     |                                            +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_mul` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_3_finite_mul.rs:130:23
[INFO] [stdout]     |
[INFO] [stdout] 130 |     assert_eq!((-0.0f64).finite_mul(5.0), Some(-0.0));
[INFO] [stdout]     |                          ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:26:5
[INFO] [stdout]     |
[INFO] [stdout]  26 |     fn finite_mul(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteMul` which provides `finite_mul` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteMul;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 130 -     assert_eq!((-0.0f64).finite_mul(5.0), Some(-0.0));
[INFO] [stdout] 130 +     assert_eq!((-0.0f64).finite_rem_euclid(5.0), Some(-0.0));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem_euclid` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_8_finite_rem_euclid.rs:170:19
[INFO] [stdout]     |
[INFO] [stdout] 170 |     assert_eq!(1e300.finite_rem_euclid(1e300), Some(0.0));
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 170 |     assert_eq!(1e300_f32.finite_rem_euclid(1e300), Some(0.0));
[INFO] [stdout]     |                     ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_4_finite_div.rs:101:19
[INFO] [stdout]     |
[INFO] [stdout] 101 |     assert_eq!(1e300.finite_div(1e-300), None);
[INFO] [stdout]     |                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 101 |     assert_eq!(1e300_f32.finite_div(1e-300), None);
[INFO] [stdout]     |                     ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_5_finite_rem.rs:143:17
[INFO] [stdout]     |
[INFO] [stdout] 143 |     assert_eq!(5.0.finite_rem(f64::NEG_INFINITY), Some(5.0));
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 143 |     assert_eq!(5.0_f32.finite_rem(f64::NEG_INFINITY), Some(5.0));
[INFO] [stdout]     |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_neg` on ambiguous numeric type `{float}`
[INFO] [stdout]   --> tests/tests_6_finite_neg.rs:94:20
[INFO] [stdout]    |
[INFO] [stdout] 94 |     assert_eq!(1e-300.finite_neg(), Some(-1e-300));
[INFO] [stdout]    |                       ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]    |
[INFO] [stdout] 94 |     assert_eq!(1e-300_f32.finite_neg(), Some(-1e-300));
[INFO] [stdout]    |                      ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] Some errors have detailed explanations: E0432, E0599, E0689.
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0432`.
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `finite-float-traits` (test "tests_8_finite_rem_euclid") due to 31 previous errors
[INFO] [stdout] error[E0689]: can't call method `finite_rem` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_5_finite_rem.rs:148:17
[INFO] [stdout]     |
[INFO] [stdout] 148 |     assert_eq!(1.0.finite_rem(3.0), Some(1.0));
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 148 |     assert_eq!(1.0_f32.finite_rem(3.0), Some(1.0));
[INFO] [stdout]     |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `finite-float-traits` (test "tests_5_finite_rem") due to 31 previous errors
[INFO] [stdout] error[E0599]: no method named `finite_neg` found for type `f64` in the current scope
[INFO] [stdout]   --> tests/tests_6_finite_neg.rs:99:34
[INFO] [stdout]    |
[INFO] [stdout] 99 |     assert_eq!(std::f64::consts::PI.finite_neg(), Some(-std::f64::consts::PI));
[INFO] [stdout]    |                                     ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lib.rs:38:5
[INFO] [stdout]    |
[INFO] [stdout] 38 |     fn finite_neg(&self) -> Option<Self>;
[INFO] [stdout]    |        ---------- the method is available for `f64` here
[INFO] [stdout]    |
[INFO] [stdout]    = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: there is a method `finite_rem` with a similar name, but with different arguments
[INFO] [stdout]   --> src/lib.rs:34:2
[INFO] [stdout]    |
[INFO] [stdout] 34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: trait `FiniteNeg` which provides `finite_neg` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]    |
[INFO] [stdout] 17 + use finite_float_traits::FiniteNeg;
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_mul` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_3_finite_mul.rs:135:23
[INFO] [stdout]     |
[INFO] [stdout] 135 |     assert_eq!((-0.0f64).finite_mul(-0.0), Some(0.0));
[INFO] [stdout]     |                          ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:26:5
[INFO] [stdout]     |
[INFO] [stdout]  26 |     fn finite_mul(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteMul` which provides `finite_mul` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteMul;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 135 -     assert_eq!((-0.0f64).finite_mul(-0.0), Some(0.0));
[INFO] [stdout] 135 +     assert_eq!((-0.0f64).finite_rem_euclid(-0.0), Some(0.0));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_5_finite_rem.rs:153:17
[INFO] [stdout]     |
[INFO] [stdout] 153 |     assert_eq!(3.0.finite_rem(1.0), Some(0.0));
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 153 |     assert_eq!(3.0_f32.finite_rem(1.0), Some(0.0));
[INFO] [stdout]     |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_4_finite_div.rs:108:15
[INFO] [stdout]     |
[INFO] [stdout] 108 |     assert_eq!(a.finite_div(b), Some(2.0));
[INFO] [stdout]     |                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:30:5
[INFO] [stdout]     |
[INFO] [stdout]  30 |     fn finite_div(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDiv` which provides `finite_div` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteDiv;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_div_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 108 |     assert_eq!(a.finite_div_euclid(b), Some(2.0));
[INFO] [stdout]     |                            +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_5_finite_rem.rs:158:19
[INFO] [stdout]     |
[INFO] [stdout] 158 |     assert_eq!(1e200.finite_rem(1e-100), Some(6.876270428777379e-101));
[INFO] [stdout]     |                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 158 |     assert_eq!(1e200_f32.finite_rem(1e-100), Some(6.876270428777379e-101));
[INFO] [stdout]     |                     ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_neg` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_6_finite_neg.rs:104:36
[INFO] [stdout]     |
[INFO] [stdout] 104 |     assert_eq!((-std::f64::consts::E).finite_neg(), Some(std::f64::consts::E));
[INFO] [stdout]     |                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:38:5
[INFO] [stdout]     |
[INFO] [stdout]  38 |     fn finite_neg(&self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: there is a method `finite_rem` with a similar name, but with different arguments
[INFO] [stdout]    --> src/lib.rs:34:2
[INFO] [stdout]     |
[INFO] [stdout]  34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: trait `FiniteNeg` which provides `finite_neg` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteNeg;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_5_finite_rem.rs:163:20
[INFO] [stdout]     |
[INFO] [stdout] 163 |     assert_eq!(1e-200.finite_rem(1e200), Some(1e-200));
[INFO] [stdout]     |                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 163 |     assert_eq!(1e-200_f32.finite_rem(1e200), Some(1e-200));
[INFO] [stdout]     |                      ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_mul` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_3_finite_mul.rs:140:17
[INFO] [stdout]     |
[INFO] [stdout] 140 |     assert_eq!(1.5.finite_mul(2.0), Some(3.0));
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 140 |     assert_eq!(1.5_f32.finite_mul(2.0), Some(3.0));
[INFO] [stdout]     |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_4_finite_div.rs:113:31
[INFO] [stdout]     |
[INFO] [stdout] 113 |     assert_eq!(f64::from_bits(1).finite_div(1e300), Some(0.0));
[INFO] [stdout]     |                                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:30:5
[INFO] [stdout]     |
[INFO] [stdout]  30 |     fn finite_div(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDiv` which provides `finite_div` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteDiv;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_div_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 113 |     assert_eq!(f64::from_bits(1).finite_div_euclid(1e300), Some(0.0));
[INFO] [stdout]     |                                            +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_neg` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_6_finite_neg.rs:109:27
[INFO] [stdout]     |
[INFO] [stdout] 109 |     assert_eq!(f64::INFINITY.finite_neg(), None);
[INFO] [stdout]     |                              ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:38:5
[INFO] [stdout]     |
[INFO] [stdout]  38 |     fn finite_neg(&self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: there is a method `finite_rem` with a similar name, but with different arguments
[INFO] [stdout]    --> src/lib.rs:34:2
[INFO] [stdout]     |
[INFO] [stdout]  34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: trait `FiniteNeg` which provides `finite_neg` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteNeg;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_rem` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_5_finite_rem.rs:168:17
[INFO] [stdout]     |
[INFO] [stdout] 168 |     assert_eq!(0.3.finite_rem(0.1), Some(0.3 % 0.1));
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 168 |     assert_eq!(0.3_f32.finite_rem(0.1), Some(0.3 % 0.1));
[INFO] [stdout]     |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_neg` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_6_finite_neg.rs:114:31
[INFO] [stdout]     |
[INFO] [stdout] 114 |     assert_eq!(f64::NEG_INFINITY.finite_neg(), None);
[INFO] [stdout]     |                                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:38:5
[INFO] [stdout]     |
[INFO] [stdout]  38 |     fn finite_neg(&self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: there is a method `finite_rem` with a similar name, but with different arguments
[INFO] [stdout]    --> src/lib.rs:34:2
[INFO] [stdout]     |
[INFO] [stdout]  34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: trait `FiniteNeg` which provides `finite_neg` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteNeg;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] Some errors have detailed explanations: E0432, E0599, E0689.
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0432`.
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_neg` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_6_finite_neg.rs:119:22
[INFO] [stdout]     |
[INFO] [stdout] 119 |     assert_eq!(f64::MAX.finite_neg(), Some(f64::MIN));
[INFO] [stdout]     |                         ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:38:5
[INFO] [stdout]     |
[INFO] [stdout]  38 |     fn finite_neg(&self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: there is a method `finite_rem` with a similar name, but with different arguments
[INFO] [stdout]    --> src/lib.rs:34:2
[INFO] [stdout]     |
[INFO] [stdout]  34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: trait `FiniteNeg` which provides `finite_neg` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteNeg;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_mul` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_3_finite_mul.rs:146:15
[INFO] [stdout]     |
[INFO] [stdout] 146 |     assert!(tiny.finite_mul(tiny).is_some());
[INFO] [stdout]     |                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a type for this binding, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 145 |     let tiny: f32 = 1e-200;
[INFO] [stdout]     |             +++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_4_finite_div.rs:118:23
[INFO] [stdout]     |
[INFO] [stdout] 118 |     assert_eq!((-0.0f64).finite_div(2.0), Some(-0.0));
[INFO] [stdout]     |                          ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:30:5
[INFO] [stdout]     |
[INFO] [stdout]  30 |     fn finite_div(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDiv` which provides `finite_div` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteDiv;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_div_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 118 |     assert_eq!((-0.0f64).finite_div_euclid(2.0), Some(-0.0));
[INFO] [stdout]     |                                    +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_neg` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_6_finite_neg.rs:124:30
[INFO] [stdout]     |
[INFO] [stdout] 124 |     assert_eq!((f64::MIN - 1.0).finite_neg(), Some(f64::MAX));
[INFO] [stdout]     |                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:38:5
[INFO] [stdout]     |
[INFO] [stdout]  38 |     fn finite_neg(&self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: there is a method `finite_rem` with a similar name, but with different arguments
[INFO] [stdout]    --> src/lib.rs:34:2
[INFO] [stdout]     |
[INFO] [stdout]  34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: trait `FiniteNeg` which provides `finite_neg` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteNeg;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_neg` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_6_finite_neg.rs:130:16
[INFO] [stdout]     |
[INFO] [stdout] 130 |     let neg = val.finite_neg().unwrap();
[INFO] [stdout]     |                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a type for this binding, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 129 |     let val: f32 = 42.0;
[INFO] [stdout]     |            +++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_mul` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_3_finite_mul.rs:153:19
[INFO] [stdout]     |
[INFO] [stdout] 153 |     assert_eq!(large.finite_mul(tiny), Some(1.0));
[INFO] [stdout]     |                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a type for this binding, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 151 |     let large: f32 = 1e200;
[INFO] [stdout]     |              +++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_neg` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_6_finite_neg.rs:137:16
[INFO] [stdout]     |
[INFO] [stdout] 137 |     let neg = 0.0.finite_neg().unwrap();
[INFO] [stdout]     |                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 137 |     let neg = 0.0_f32.finite_neg().unwrap();
[INFO] [stdout]     |                  ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_4_finite_div.rs:123:27
[INFO] [stdout]     |
[INFO] [stdout] 123 |     assert_eq!(f64::INFINITY.finite_div(f64::INFINITY), None);
[INFO] [stdout]     |                              ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:30:5
[INFO] [stdout]     |
[INFO] [stdout]  30 |     fn finite_div(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDiv` which provides `finite_div` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteDiv;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_div_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 123 |     assert_eq!(f64::INFINITY.finite_div_euclid(f64::INFINITY), None);
[INFO] [stdout]     |                                        +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_neg` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_6_finite_neg.rs:145:16
[INFO] [stdout]     |
[INFO] [stdout] 145 |     let neg = sub.finite_neg().unwrap();
[INFO] [stdout]     |                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:38:5
[INFO] [stdout]     |
[INFO] [stdout]  38 |     fn finite_neg(&self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: there is a method `finite_rem` with a similar name, but with different arguments
[INFO] [stdout]    --> src/lib.rs:34:2
[INFO] [stdout]     |
[INFO] [stdout]  34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: trait `FiniteNeg` which provides `finite_neg` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteNeg;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_neg` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_6_finite_neg.rs:152:31
[INFO] [stdout]     |
[INFO] [stdout] 152 |     assert_eq!(f64::MIN_POSITIVE.finite_neg(), Some(-f64::MIN_POSITIVE));
[INFO] [stdout]     |                                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:38:5
[INFO] [stdout]     |
[INFO] [stdout]  38 |     fn finite_neg(&self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: there is a method `finite_rem` with a similar name, but with different arguments
[INFO] [stdout]    --> src/lib.rs:34:2
[INFO] [stdout]     |
[INFO] [stdout]  34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: trait `FiniteNeg` which provides `finite_neg` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteNeg;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_mul` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_3_finite_mul.rs:158:27
[INFO] [stdout]     |
[INFO] [stdout] 158 |     assert_eq!(f64::INFINITY.finite_mul(f64::INFINITY), None);
[INFO] [stdout]     |                              ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:26:5
[INFO] [stdout]     |
[INFO] [stdout]  26 |     fn finite_mul(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteMul` which provides `finite_mul` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteMul;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 158 -     assert_eq!(f64::INFINITY.finite_mul(f64::INFINITY), None);
[INFO] [stdout] 158 +     assert_eq!(f64::INFINITY.finite_rem_euclid(f64::INFINITY), None);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_neg` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_6_finite_neg.rs:158:17
[INFO] [stdout]     |
[INFO] [stdout] 158 |     assert_eq!(val.finite_neg(), Some(f64::MIN_POSITIVE));
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:38:5
[INFO] [stdout]     |
[INFO] [stdout]  38 |     fn finite_neg(&self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: there is a method `finite_rem` with a similar name, but with different arguments
[INFO] [stdout]    --> src/lib.rs:34:2
[INFO] [stdout]     |
[INFO] [stdout]  34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: trait `FiniteNeg` which provides `finite_neg` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteNeg;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_4_finite_div.rs:128:31
[INFO] [stdout]     |
[INFO] [stdout] 128 |     assert_eq!(f64::NEG_INFINITY.finite_div(1.0), None);
[INFO] [stdout]     |                                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:30:5
[INFO] [stdout]     |
[INFO] [stdout]  30 |     fn finite_div(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDiv` which provides `finite_div` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteDiv;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_div_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 128 |     assert_eq!(f64::NEG_INFINITY.finite_div_euclid(1.0), None);
[INFO] [stdout]     |                                            +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_neg` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_6_finite_neg.rs:164:15
[INFO] [stdout]     |
[INFO] [stdout] 164 |     assert!(near.finite_neg().is_some());
[INFO] [stdout]     |                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:38:5
[INFO] [stdout]     |
[INFO] [stdout]  38 |     fn finite_neg(&self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: there is a method `finite_rem` with a similar name, but with different arguments
[INFO] [stdout]    --> src/lib.rs:34:2
[INFO] [stdout]     |
[INFO] [stdout]  34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: trait `FiniteNeg` which provides `finite_neg` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteNeg;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_mul` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_3_finite_mul.rs:163:31
[INFO] [stdout]     |
[INFO] [stdout] 163 |     assert_eq!(f64::NEG_INFINITY.finite_mul(f64::NEG_INFINITY), None);
[INFO] [stdout]     |                                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:26:5
[INFO] [stdout]     |
[INFO] [stdout]  26 |     fn finite_mul(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteMul` which provides `finite_mul` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteMul;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 163 -     assert_eq!(f64::NEG_INFINITY.finite_mul(f64::NEG_INFINITY), None);
[INFO] [stdout] 163 +     assert_eq!(f64::NEG_INFINITY.finite_rem_euclid(f64::NEG_INFINITY), None);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_neg` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_6_finite_neg.rs:170:15
[INFO] [stdout]     |
[INFO] [stdout] 170 |     assert!(near.finite_neg().is_some());
[INFO] [stdout]     |                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:38:5
[INFO] [stdout]     |
[INFO] [stdout]  38 |     fn finite_neg(&self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: there is a method `finite_rem` with a similar name, but with different arguments
[INFO] [stdout]    --> src/lib.rs:34:2
[INFO] [stdout]     |
[INFO] [stdout]  34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: trait `FiniteNeg` which provides `finite_neg` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteNeg;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_4_finite_div.rs:133:19
[INFO] [stdout]     |
[INFO] [stdout] 133 |     let result = 1.0.finite_div(3.0);
[INFO] [stdout]     |                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 133 |     let result = 1.0_f32.finite_div(3.0);
[INFO] [stdout]     |                     ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_neg` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_6_finite_neg.rs:175:17
[INFO] [stdout]     |
[INFO] [stdout] 175 |     assert_eq!(0.1.finite_neg(), Some(-0.1));
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 175 |     assert_eq!(0.1_f32.finite_neg(), Some(-0.1));
[INFO] [stdout]     |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_neg` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_6_finite_neg.rs:180:20
[INFO] [stdout]     |
[INFO] [stdout] 180 |     let a = (-0.0f64).finite_neg().unwrap();
[INFO] [stdout]     |                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:38:5
[INFO] [stdout]     |
[INFO] [stdout]  38 |     fn finite_neg(&self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: there is a method `finite_rem` with a similar name, but with different arguments
[INFO] [stdout]    --> src/lib.rs:34:2
[INFO] [stdout]     |
[INFO] [stdout]  34 |     fn finite_rem(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: trait `FiniteNeg` which provides `finite_neg` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteNeg;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_mul` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_3_finite_mul.rs:168:20
[INFO] [stdout]     |
[INFO] [stdout] 168 |     assert_eq!((-1.0).finite_mul(f64::MAX), Some(f64::MIN));
[INFO] [stdout]     |                       ^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `finite-float-traits` (test "tests_6_finite_neg") due to 31 previous errors
[INFO] [stdout] Some errors have detailed explanations: E0432, E0599, E0689.
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0432`.
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_4_finite_div.rs:140:22
[INFO] [stdout]     |
[INFO] [stdout] 140 |     assert_eq!(f64::MAX.finite_div(0.5), None);
[INFO] [stdout]     |                         ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:30:5
[INFO] [stdout]     |
[INFO] [stdout]  30 |     fn finite_div(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDiv` which provides `finite_div` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteDiv;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_div_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 140 |     assert_eq!(f64::MAX.finite_div_euclid(0.5), None);
[INFO] [stdout]     |                                   +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_mul` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_3_finite_mul.rs:173:31
[INFO] [stdout]     |
[INFO] [stdout] 173 |     assert_eq!(f64::MIN_POSITIVE.finite_mul(f64::MAX), Some(f64::MIN_POSITIVE * f64::MAX));
[INFO] [stdout]     |                                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:26:5
[INFO] [stdout]     |
[INFO] [stdout]  26 |     fn finite_mul(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteMul` which provides `finite_mul` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteMul;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_rem_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 173 -     assert_eq!(f64::MIN_POSITIVE.finite_mul(f64::MAX), Some(f64::MIN_POSITIVE * f64::MAX));
[INFO] [stdout] 173 +     assert_eq!(f64::MIN_POSITIVE.finite_rem_euclid(f64::MAX), Some(f64::MIN_POSITIVE * f64::MAX));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_4_finite_div.rs:145:22
[INFO] [stdout]     |
[INFO] [stdout] 145 |     assert_eq!(f64::MIN.finite_div(0.5), None);
[INFO] [stdout]     |                         ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:30:5
[INFO] [stdout]     |
[INFO] [stdout]  30 |     fn finite_div(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDiv` which provides `finite_div` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteDiv;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_div_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 145 |     assert_eq!(f64::MIN.finite_div_euclid(0.5), None);
[INFO] [stdout]     |                                   +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] Some errors have detailed explanations: E0432, E0599, E0689.
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0432`.
[INFO] [stdout] 
[INFO] [stdout] error[E0599]: no method named `finite_div` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_4_finite_div.rs:150:22
[INFO] [stdout]     |
[INFO] [stdout] 150 |     assert_eq!(f64::MAX.finite_div(-1.0), Some(f64::MIN));
[INFO] [stdout]     |                         ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:30:5
[INFO] [stdout]     |
[INFO] [stdout]  30 |     fn finite_div(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDiv` which provides `finite_div` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteDiv;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_div_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 150 |     assert_eq!(f64::MAX.finite_div_euclid(-1.0), Some(f64::MIN));
[INFO] [stdout]     |                                   +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `finite-float-traits` (test "tests_3_finite_mul") due to 31 previous errors
[INFO] [stdout] error[E0599]: no method named `finite_div` found for type `f64` in the current scope
[INFO] [stdout]    --> tests/tests_4_finite_div.rs:155:22
[INFO] [stdout]     |
[INFO] [stdout] 155 |     assert_eq!(f64::MIN.finite_div(-1.0), Some(f64::MAX));
[INFO] [stdout]     |                         ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lib.rs:30:5
[INFO] [stdout]     |
[INFO] [stdout]  30 |     fn finite_div(&self, rhs: Self) -> Option<Self>;
[INFO] [stdout]     |        ---------- the method is available for `f64` here
[INFO] [stdout]     |
[INFO] [stdout]     = help: items from traits can only be used if the trait is in scope
[INFO] [stdout] help: trait `FiniteDiv` which provides `finite_div` is implemented but not in scope; perhaps you want to import it
[INFO] [stdout]     |
[INFO] [stdout]  17 + use finite_float_traits::FiniteDiv;
[INFO] [stdout]     |
[INFO] [stdout] help: there is a method `finite_div_euclid` with a similar name
[INFO] [stdout]     |
[INFO] [stdout] 155 |     assert_eq!(f64::MIN.finite_div_euclid(-1.0), Some(f64::MAX));
[INFO] [stdout]     |                                   +++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_4_finite_div.rs:160:19
[INFO] [stdout]     |
[INFO] [stdout] 160 |     assert_eq!(1e200.finite_div(1e100), Some(1e100));
[INFO] [stdout]     |                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 160 |     assert_eq!(1e200_f32.finite_div(1e100), Some(1e100));
[INFO] [stdout]     |                     ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_4_finite_div.rs:165:17
[INFO] [stdout]     |
[INFO] [stdout] 165 |     assert_eq!(2.0.finite_div(2.0), Some(1.0));
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 165 |     assert_eq!(2.0_f32.finite_div(2.0), Some(1.0));
[INFO] [stdout]     |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0689]: can't call method `finite_div` on ambiguous numeric type `{float}`
[INFO] [stdout]    --> tests/tests_4_finite_div.rs:170:17
[INFO] [stdout]     |
[INFO] [stdout] 170 |     assert_eq!(1.0.finite_div(f64::MIN_POSITIVE), Some(1.0 / f64::MIN_POSITIVE));
[INFO] [stdout]     |                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout] help: you must specify a concrete type for this numeric value, like `f32`
[INFO] [stdout]     |
[INFO] [stdout] 170 |     assert_eq!(1.0_f32.finite_div(f64::MIN_POSITIVE), Some(1.0 / f64::MIN_POSITIVE));
[INFO] [stdout]     |                   ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] Some errors have detailed explanations: E0432, E0599, E0689.
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0432`.
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `finite-float-traits` (test "tests_4_finite_div") due to 31 previous errors
[INFO] running `Command { std: "docker" "inspect" "8016f2a611df1d603bc5f57f76e19ea3edd067758863be0221219c5d2879caff", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "8016f2a611df1d603bc5f57f76e19ea3edd067758863be0221219c5d2879caff", kill_on_drop: false }`
[INFO] [stdout] 8016f2a611df1d603bc5f57f76e19ea3edd067758863be0221219c5d2879caff
